diff --git a/core-rust/core-api-server/core-api-schema.yaml b/core-rust/core-api-server/core-api-schema.yaml index 4678661ee1..bcb2ce5a52 100644 --- a/core-rust/core-api-server/core-api-schema.yaml +++ b/core-rust/core-api-server/core-api-schema.yaml @@ -53,8 +53,8 @@ openapi: 3.1.0 # => Hex-encoded bytes/payload should end _hex and not include _bytes info: # Should be the release version, and the release display name - version: 'v1.0.4' - title: 'Radix Core API - Babylon' + version: 'v1.1.0' + title: 'Radix Core API - Babylon (Anemone)' license: name: The Radix License, Version 1.0 url: https://www.radixfoundation.org/licenses/license-v1 @@ -207,7 +207,7 @@ tags: For reading the state of entities. At present, we only support reading details from the top of the currently committed ledger. - name: Stream x-displayName: Stream Endpoints - description: To query the transaction stream of the ledger. + description: To query the transaction or proof stream of the ledger. paths: ################################################## # Long Term Support backwards compatible Sub-API # diff --git a/core-rust/core-api-server/src/core_api/generated/mod.rs b/core-rust/core-api-server/src/core_api/generated/mod.rs index a7a185a6ac..efadc56fe1 100644 --- a/core-rust/core-api-server/src/core_api/generated/mod.rs +++ b/core-rust/core-api-server/src/core_api/generated/mod.rs @@ -1,2 +1,2 @@ pub mod models; -pub const SCHEMA_VERSION: &str = "v1.0.4"; +pub const SCHEMA_VERSION: &str = "v1.1.0"; diff --git a/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_substate.rs index e8d928cc8b..25c598b85e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_substate_all_of.rs index a73b514a6a..6e2c412210 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_value.rs index a5374bc010..f2707a5704 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/access_controller_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/access_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/access_rule.rs index 03a84a2a32..733c883800 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/access_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/access_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/access_rule_node.rs b/core-rust/core-api-server/src/core_api/generated/models/access_rule_node.rs index cec6d9ed90..914e166e1b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/access_rule_node.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/access_rule_node.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/access_rule_node_type.rs b/core-rust/core-api-server/src/core_api/generated/models/access_rule_node_type.rs index 3ca9626228..75f1332c4d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/access_rule_node_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/access_rule_node_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/access_rule_type.rs b/core-rust/core-api-server/src/core_api/generated/models/access_rule_type.rs index c2e0bd2fec..0147069625 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/access_rule_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/access_rule_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_substate.rs index 15e3976741..2ff308be98 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_substate_all_of.rs index 12df67c98e..01aae36d07 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_value.rs index 7a5ca7f303..e474b09eb6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_authorized_depositor_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/account_field_state_substate.rs index 2c79cb1949..1bd2b9b81a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/account_field_state_substate_all_of.rs index 523c931c50..73c39bbcb4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/account_field_state_value.rs index 1e8e87920a..7a7e278f6a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_substate.rs index 12101c5a1e..7fb4834167 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_substate_all_of.rs index 4d4113e3ae..019948dba8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_value.rs index d5e2e98f27..19978da83f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_resource_preference_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_substate.rs index 7ec51eb646..23787c1fad 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_substate_all_of.rs index 64ff133762..59071696a5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_value.rs index 7b8f399bbd..4246d05211 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/account_vault_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/active_validator.rs b/core-rust/core-api-server/src/core_api/generated/models/active_validator.rs index 3b33373a59..36b7d552e3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/active_validator.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/active_validator.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/active_validator_index.rs b/core-rust/core-api-server/src/core_api/generated/models/active_validator_index.rs index eb4cd9d1e3..45392f6e0a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/active_validator_index.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/active_validator_index.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/active_validator_key.rs b/core-rust/core-api-server/src/core_api/generated/models/active_validator_key.rs index 288c20c985..3f1ee341fd 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/active_validator_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/active_validator_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/address_type.rs b/core-rust/core-api-server/src/core_api/generated/models/address_type.rs index b5e8f5b272..b6d215092f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/address_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/address_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/all_of_access_rule_node.rs b/core-rust/core-api-server/src/core_api/generated/models/all_of_access_rule_node.rs index 0799e30a66..33e4e03227 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/all_of_access_rule_node.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/all_of_access_rule_node.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/all_of_proof_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/all_of_proof_rule.rs index 253ea68510..bf3762deb7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/all_of_proof_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/all_of_proof_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/all_of_proof_rule_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/all_of_proof_rule_all_of.rs index 6d52237da5..98822149af 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/all_of_proof_rule_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/all_of_proof_rule_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/allow_all_access_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/allow_all_access_rule.rs index 2cdf912d2f..0c64452943 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/allow_all_access_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/allow_all_access_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/amount_of_proof_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/amount_of_proof_rule.rs index 5ac475eca2..6df6edd786 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/amount_of_proof_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/amount_of_proof_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/amount_of_proof_rule_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/amount_of_proof_rule_all_of.rs index 068d1f21bb..fea3fd51d2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/amount_of_proof_rule_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/amount_of_proof_rule_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/any_of_access_rule_node.rs b/core-rust/core-api-server/src/core_api/generated/models/any_of_access_rule_node.rs index bbef5670a0..a82b5d9321 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/any_of_access_rule_node.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/any_of_access_rule_node.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/any_of_access_rule_node_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/any_of_access_rule_node_all_of.rs index a67413c914..27878281cd 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/any_of_access_rule_node_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/any_of_access_rule_node_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/any_of_proof_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/any_of_proof_rule.rs index 970611ec29..b9a71a7de8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/any_of_proof_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/any_of_proof_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/attached_module_id.rs b/core-rust/core-api-server/src/core_api/generated/models/attached_module_id.rs index b0d2893928..3c319ace03 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/attached_module_id.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/attached_module_id.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/auth_config.rs b/core-rust/core-api-server/src/core_api/generated/models/auth_config.rs index 813fc6ac74..4c46e0be74 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/auth_config.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/auth_config.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_badge.rs b/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_badge.rs index b32a3c7fa7..fafbfdfc67 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_badge.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_badge.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_badge_type.rs b/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_badge_type.rs index 3ac458eb3a..6546d15400 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_badge_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_badge_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_key.rs b/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_key.rs index b3ded1bf3d..bff8a9d2b4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/authorized_depositor_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/basic_error_response.rs b/core-rust/core-api-server/src/core_api/generated/models/basic_error_response.rs index 9ecb44d445..85c675fccc 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/basic_error_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/basic_error_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/binary_plaintext_message_content.rs b/core-rust/core-api-server/src/core_api/generated/models/binary_plaintext_message_content.rs index 054cc61791..f877219ddb 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/binary_plaintext_message_content.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/binary_plaintext_message_content.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/binary_plaintext_message_content_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/binary_plaintext_message_content_all_of.rs index c11445b99a..904707f2d9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/binary_plaintext_message_content_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/binary_plaintext_message_content_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_collection_schema.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_collection_schema.rs index 5b0ab96a65..4eb606f12c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_collection_schema.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_collection_schema.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_collection_schema_type.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_collection_schema_type.rs index acf05b6462..facfb96c4c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_collection_schema_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_collection_schema_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_definition.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_definition.rs index c12a8f2729..00fd1439c2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_definition.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_definition.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_dependencies.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_dependencies.rs index f34bf84c04..684503c70c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_dependencies.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_dependencies.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_function_target_identifier.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_function_target_identifier.rs index b238d647f6..227b96cb3e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_function_target_identifier.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_function_target_identifier.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_function_target_identifier_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_function_target_identifier_all_of.rs index ac9880cb48..7e942f7583 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_function_target_identifier_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_function_target_identifier_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_info.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_info.rs index 9584db8473..9b3ab86aba 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_info.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_info.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_interface.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_interface.rs index cfd0c9833c..03b140106a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_interface.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_interface.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_method_royalty.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_method_royalty.rs index ceb23577b7..c4814507f8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_method_royalty.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_method_royalty.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_payload_def.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_payload_def.rs index 4af26c7c6c..6af8949a65 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_payload_def.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_payload_def.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_payload_def_type.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_payload_def_type.rs index a5422f6818..17c89aba18 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_payload_def_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_payload_def_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_royalty_config.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_royalty_config.rs index b0af41cacd..fc2843e824 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_royalty_config.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_royalty_config.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_blueprint_type_reference.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_blueprint_type_reference.rs index 0c0072de60..4079cddf79 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_blueprint_type_reference.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_blueprint_type_reference.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_blueprint_type_reference_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_blueprint_type_reference_all_of.rs index 80ea5355ca..3f165dd6a1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_blueprint_type_reference_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_blueprint_type_reference_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_collection_partition.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_collection_partition.rs index 194c78d49f..50ee04656d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_collection_partition.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_collection_partition.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_field_partition.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_field_partition.rs index 063833f95b..ba0341c14f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_field_partition.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_schema_field_partition.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_identifier.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_identifier.rs index db78ee71d2..f976b33133 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_identifier.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_identifier.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_reference.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_reference.rs index 3d1d20004e..f2d5344503 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_reference.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_reference.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_reference_kind.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_reference_kind.rs index a37b640a66..9b7224a1ce 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_reference_kind.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_type_reference_kind.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/blueprint_version_key.rs b/core-rust/core-api-server/src/core_api/generated/models/blueprint_version_key.rs index 295f1a7b05..08e459ddd8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/blueprint_version_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/blueprint_version_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_substate.rs index 022378d559..ab2208a9c8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_substate_all_of.rs index 8c017c1436..5fd5b137f1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_value.rs b/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_value.rs index ca15089221..504064ec74 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/boot_loader_module_field_vm_boot_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/committed_intent_metadata.rs b/core-rust/core-api-server/src/core_api/generated/models/committed_intent_metadata.rs index b0aa23fddc..75fbf7bd90 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/committed_intent_metadata.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/committed_intent_metadata.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/committed_state_identifier.rs b/core-rust/core-api-server/src/core_api/generated/models/committed_state_identifier.rs index 6d5c7c8337..2024258836 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/committed_state_identifier.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/committed_state_identifier.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/committed_state_identifier_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/committed_state_identifier_all_of.rs index c3c557bf27..39d4439a88 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/committed_state_identifier_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/committed_state_identifier_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/committed_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/committed_transaction.rs index c3d03f44d9..2fd56be026 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/committed_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/committed_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/committed_transaction_balance_changes.rs b/core-rust/core-api-server/src/core_api/generated/models/committed_transaction_balance_changes.rs index 930e609785..0dbe9f3373 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/committed_transaction_balance_changes.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/committed_transaction_balance_changes.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/component_method_target_identifier.rs b/core-rust/core-api-server/src/core_api/generated/models/component_method_target_identifier.rs index 7f79a02c7e..2b98363e59 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/component_method_target_identifier.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/component_method_target_identifier.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/component_method_target_identifier_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/component_method_target_identifier_all_of.rs index 9de2b334db..e06ec6f6e9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/component_method_target_identifier_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/component_method_target_identifier_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_ledger_proof_origin.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_ledger_proof_origin.rs index a30c48d78d..67f6e5030d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_ledger_proof_origin.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_ledger_proof_origin.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_ledger_proof_origin_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_ledger_proof_origin_all_of.rs index bb78c57db4..1bff60e040 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_ledger_proof_origin_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_ledger_proof_origin_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_substate.rs index dfb12918c7..87726663f6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_substate_all_of.rs index 2ee2a1f0ba..23cf3c50a6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_value.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_value.rs index 01fa93a734..d63c51550b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_config_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_substate.rs index d57cb4b628..fe33af36ed 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_substate_all_of.rs index 856882cd84..fa58a2eeca 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_value.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_value.rs index 4868339d95..ad3a80af62 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_proposal_statistic_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_substate.rs index 2674a2dd62..23a98c72d9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_substate_all_of.rs index f385f4852f..e4f9f19593 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_value.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_value.rs index 76c2e815d4..281a96c6fa 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_rounded_to_minutes_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_substate.rs index 6602f822c0..8ca54cc60b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_substate_all_of.rs index 449690490f..1f176cf8da 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_value.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_value.rs index f3166d1597..364628f75a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_time_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_substate.rs index 28f6329d36..0efcd75e5b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_substate_all_of.rs index 44294b810f..7972bbe8a2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_value.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_value.rs index c8407bd878..9794cdde84 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_current_validator_set_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_substate.rs index 8f6af41362..06a46696ea 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_substate_all_of.rs index c35680790c..cac2380826 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_value.rs index be1c44647d..37f2ddb56a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_substate.rs index d8545306f3..9a7e716b7c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_substate_all_of.rs index 9e5b486081..07ecedd017 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_value.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_value.rs index 8006a2ce86..457756abd0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_field_validator_rewards_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_substate.rs index 010bcfd10d..298100e4b3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_substate_all_of.rs index 814f01d386..cde6c947b4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_value.rs index 79573dd9e6..5a3f0aeeb7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/consensus_manager_registered_validators_by_stake_index_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/costing_parameters.rs b/core-rust/core-api-server/src/core_api/generated/models/costing_parameters.rs index 6a03c47e68..3c6d736ed5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/costing_parameters.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/costing_parameters.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/count_of_proof_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/count_of_proof_rule.rs index 3b11bbbf19..addb750145 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/count_of_proof_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/count_of_proof_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/count_of_proof_rule_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/count_of_proof_rule_all_of.rs index a7d4888d12..9f7914ea66 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/count_of_proof_rule_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/count_of_proof_rule_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/created_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/created_substate.rs index cc259f9f28..d3a84c6cb8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/created_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/created_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/data_struct.rs b/core-rust/core-api-server/src/core_api/generated/models/data_struct.rs index f8fae9e7fc..6a82ab96d1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/data_struct.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/data_struct.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/default_deposit_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/default_deposit_rule.rs index caed9a2807..e3a0afa5aa 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/default_deposit_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/default_deposit_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/deleted_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/deleted_substate.rs index 40909403b0..6a2e7a0251 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/deleted_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/deleted_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/deny_all_access_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/deny_all_access_rule.rs index 7e81e20470..d11e4c5f3b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/deny_all_access_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/deny_all_access_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_public_key.rs b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_public_key.rs index c3e56b127b..c8b29ee343 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_public_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_public_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_public_key_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_public_key_all_of.rs index d3a1292aa1..6f88deb709 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_public_key_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_public_key_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature.rs b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature.rs index 0da691efb0..4981ebcbd1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_all_of.rs index 978cab8ddf..98f689ff72 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_with_public_key.rs b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_with_public_key.rs index 945dfa125d..9bdbcf45b8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_with_public_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_with_public_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_with_public_key_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_with_public_key_all_of.rs index 06d3e18aff..a69842f1c9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_with_public_key_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ecdsa_secp256k1_signature_with_public_key_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_public_key.rs b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_public_key.rs index e224de1420..beb95af1e3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_public_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_public_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_public_key_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_public_key_all_of.rs index 0bb24fa926..b27dc3c9d8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_public_key_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_public_key_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature.rs b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature.rs index c5f67fda52..060c788f97 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_all_of.rs index b33d6e710b..6699b10907 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_with_public_key.rs b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_with_public_key.rs index ff55b44162..d553ba85e1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_with_public_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_with_public_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_with_public_key_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_with_public_key_all_of.rs index 06341ebaae..0d1b301e12 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_with_public_key_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/eddsa_ed25519_signature_with_public_key_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/encrypted_message_curve_decryptor_set.rs b/core-rust/core-api-server/src/core_api/generated/models/encrypted_message_curve_decryptor_set.rs index 971bd5b30f..4ee92b7628 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/encrypted_message_curve_decryptor_set.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/encrypted_message_curve_decryptor_set.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/encrypted_message_decryptor.rs b/core-rust/core-api-server/src/core_api/generated/models/encrypted_message_decryptor.rs index eb4ba798c3..08e0a55c34 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/encrypted_message_decryptor.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/encrypted_message_decryptor.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/encrypted_transaction_message.rs b/core-rust/core-api-server/src/core_api/generated/models/encrypted_transaction_message.rs index 10f2ebec9d..3259a1867f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/encrypted_transaction_message.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/encrypted_transaction_message.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/encrypted_transaction_message_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/encrypted_transaction_message_all_of.rs index c23cc67299..c46202e1d3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/encrypted_transaction_message_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/encrypted_transaction_message_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/entity_module.rs b/core-rust/core-api-server/src/core_api/generated/models/entity_module.rs index 43ab8206dd..381efed7f9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/entity_module.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/entity_module.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/entity_reference.rs b/core-rust/core-api-server/src/core_api/generated/models/entity_reference.rs index fdd5d17c97..3fbc34a461 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/entity_reference.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/entity_reference.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/entity_type.rs b/core-rust/core-api-server/src/core_api/generated/models/entity_type.rs index ff11be3661..ad03e5ef65 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/entity_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/entity_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/epoch_change_condition.rs b/core-rust/core-api-server/src/core_api/generated/models/epoch_change_condition.rs index 94e25a8eeb..dc4c3dbd6a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/epoch_change_condition.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/epoch_change_condition.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/epoch_end_ledger_proof.rs b/core-rust/core-api-server/src/core_api/generated/models/epoch_end_ledger_proof.rs index b24c401811..09a884e9b0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/epoch_end_ledger_proof.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/epoch_end_ledger_proof.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/epoch_round.rs b/core-rust/core-api-server/src/core_api/generated/models/epoch_round.rs index 0e9e5f1a97..eacc54b077 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/epoch_round.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/epoch_round.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/error_response.rs b/core-rust/core-api-server/src/core_api/generated/models/error_response.rs index ed0f13e3db..bb520c6430 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/error_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/error_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/error_response_type.rs b/core-rust/core-api-server/src/core_api/generated/models/error_response_type.rs index a2b8b487ee..07888e6b6d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/error_response_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/error_response_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/event.rs b/core-rust/core-api-server/src/core_api/generated/models/event.rs index decab0c520..437dff296e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/event.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/event.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/event_emitter_identifier.rs b/core-rust/core-api-server/src/core_api/generated/models/event_emitter_identifier.rs index 43fb0f2543..4557d84f4a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/event_emitter_identifier.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/event_emitter_identifier.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/event_emitter_identifier_type.rs b/core-rust/core-api-server/src/core_api/generated/models/event_emitter_identifier_type.rs index b407f1b541..e9634fa64e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/event_emitter_identifier_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/event_emitter_identifier_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/event_type_identifier.rs b/core-rust/core-api-server/src/core_api/generated/models/event_type_identifier.rs index 94d0649b43..e2b745536e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/event_type_identifier.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/event_type_identifier.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/executed_genesis_scenario.rs b/core-rust/core-api-server/src/core_api/generated/models/executed_genesis_scenario.rs index d20ebadb9d..ea5e6a8f84 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/executed_genesis_scenario.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/executed_genesis_scenario.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/executed_scenario_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/executed_scenario_transaction.rs index e8c6b8f399..f76da9958b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/executed_scenario_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/executed_scenario_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fee_destination.rs b/core-rust/core-api-server/src/core_api/generated/models/fee_destination.rs index 6cb706244c..51043e7a65 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fee_destination.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fee_destination.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fee_source.rs b/core-rust/core-api-server/src/core_api/generated/models/fee_source.rs index 9c73f5f6df..ea5954f7c4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fee_source.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fee_source.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fee_summary.rs b/core-rust/core-api-server/src/core_api/generated/models/fee_summary.rs index 1975daf7b8..28167b888c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fee_summary.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fee_summary.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/field_schema.rs b/core-rust/core-api-server/src/core_api/generated/models/field_schema.rs index 0647d9286c..6c993215c5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/field_schema.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/field_schema.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition.rs b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition.rs index b0b59bfbed..db32f3737f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_always.rs b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_always.rs index b6b60be45a..1fab5f8c42 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_always.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_always.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_outer_object_feature.rs b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_outer_object_feature.rs index 5054b912eb..0c2de67d2d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_outer_object_feature.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_outer_object_feature.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_own_feature.rs b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_own_feature.rs index 6e5d6974fe..606b615fa3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_own_feature.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_own_feature.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_own_feature_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_own_feature_all_of.rs index 85a819b6b4..d0a1db938c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_own_feature_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_if_own_feature_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_type.rs b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_type.rs index 15ccf1e133..b9a2cb5ef5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/field_schema_feature_condition_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/field_substate_key.rs b/core-rust/core-api-server/src/core_api/generated/models/field_substate_key.rs index 9c3bd02850..779b517570 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/field_substate_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/field_substate_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/field_substate_key_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/field_substate_key_all_of.rs index d2ae4ab828..c9dab4a366 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/field_substate_key_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/field_substate_key_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/flash_ledger_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/flash_ledger_transaction.rs index 92db124919..bb32b2e9ea 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/flash_ledger_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/flash_ledger_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/flash_ledger_transaction_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/flash_ledger_transaction_all_of.rs index d9db35fc0d..4a29736eff 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/flash_ledger_transaction_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/flash_ledger_transaction_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/flash_set_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/flash_set_substate.rs index e9fd243cf4..59a3769fe4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/flash_set_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/flash_set_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/flashed_state_updates.rs b/core-rust/core-api-server/src/core_api/generated/models/flashed_state_updates.rs index 2edbe80f5b..120a3fb0a4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/flashed_state_updates.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/flashed_state_updates.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/frozen_status.rs b/core-rust/core-api-server/src/core_api/generated/models/frozen_status.rs index 4ae3610dc8..ab64000384 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/frozen_status.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/frozen_status.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fully_scoped_type_id.rs b/core-rust/core-api-server/src/core_api/generated/models/fully_scoped_type_id.rs index b878141ceb..f65e9148e6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fully_scoped_type_id.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fully_scoped_type_id.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/function_auth_type.rs b/core-rust/core-api-server/src/core_api/generated/models/function_auth_type.rs index 83883ae1d7..f838356b9d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/function_auth_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/function_auth_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/function_event_emitter_identifier.rs b/core-rust/core-api-server/src/core_api/generated/models/function_event_emitter_identifier.rs index e88af7c493..d6cbf9252f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/function_event_emitter_identifier.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/function_event_emitter_identifier.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/function_event_emitter_identifier_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/function_event_emitter_identifier_all_of.rs index 0cacf5c460..a302d3aef1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/function_event_emitter_identifier_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/function_event_emitter_identifier_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/function_schema.rs b/core-rust/core-api-server/src/core_api/generated/models/function_schema.rs index 0a37f89728..54f37b4b89 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/function_schema.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/function_schema.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_amount.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_amount.rs index 5c26a2de84..6557f2d57a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_amount.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_amount.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_amount_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_amount_all_of.rs index bfc96a284e..750ab61878 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_amount_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_amount_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_substate.rs index 3c4c20ee7e..12ee8fb647 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_substate_all_of.rs index f81a2875ac..6546624d92 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_value.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_value.rs index 55e964e8e3..1e9d0ba697 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_divisibility_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_substate.rs index 84a6e5c785..01ea4f8e1d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_substate_all_of.rs index 219062b048..09c260349d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_value.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_value.rs index f3225a7dd9..25673d056f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_resource_manager_field_total_supply_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_substate.rs index 1b42c0c9c3..a06286cf17 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_substate_all_of.rs index 7a07b29b36..217e53c5d6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_value.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_value.rs index 0800a065e4..6f5fc515ac 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_balance_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_substate.rs index 6caa1329e6..6a16273e5c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_substate_all_of.rs index 089ef729a3..e0f62fc9f3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_value.rs b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_value.rs index db9b17203e..674a286233 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/fungible_vault_field_frozen_status_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_blueprint_payload_def.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_blueprint_payload_def.rs index ddbfe724ac..a589f002d0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_blueprint_payload_def.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_blueprint_payload_def.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_blueprint_payload_def_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_blueprint_payload_def_all_of.rs index 1472c01f3d..5c71c5df5e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_blueprint_payload_def_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_blueprint_payload_def_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_key.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_key.rs index bd5932d819..ed7679a1ba 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_substate.rs index 0c15b5c838..ae51f469ab 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_substate_all_of.rs index e9be15392f..9fc58c5c62 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_value.rs index 5151ded390..e1806af8f7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_key_value_store_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_substate.rs index 0bba574301..dbe5472c29 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_substate_all_of.rs index 17d4df7515..f5aa9b00ee 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_value.rs index ea868302ce..7a78d58cd3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_scrypto_component_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_substitution.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_substitution.rs index fa60645c51..0466139122 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_substitution.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_substitution.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_substitution_type.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_substitution_type.rs index c7283adc2e..130a416446 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_substitution_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_substitution_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_type_parameter.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_type_parameter.rs index cd0b6587d4..09f5fa30fa 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_type_parameter.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_type_parameter.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/generic_type_parameter_constraints.rs b/core-rust/core-api-server/src/core_api/generated/models/generic_type_parameter_constraints.rs index 4f0ec3635d..bc6aae4388 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/generic_type_parameter_constraints.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/generic_type_parameter_constraints.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_proof_origin.rs b/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_proof_origin.rs index e742384550..14c6a2c63b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_proof_origin.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_proof_origin.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_proof_origin_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_proof_origin_all_of.rs index 22ef63b447..0c1a9d888a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_proof_origin_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_proof_origin_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_transaction.rs index 4e6c789b2c..3c6dde30ee 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_transaction_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_transaction_all_of.rs index ae0496f0ea..df090b13ae 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_transaction_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/genesis_ledger_transaction_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/hook_export.rs b/core-rust/core-api-server/src/core_api/generated/models/hook_export.rs index 3eabc2624c..a20a597443 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/hook_export.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/hook_export.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/index_blueprint_collection_schema.rs b/core-rust/core-api-server/src/core_api/generated/models/index_blueprint_collection_schema.rs index d12f8de07d..3a59c42a3a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/index_blueprint_collection_schema.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/index_blueprint_collection_schema.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/index_blueprint_collection_schema_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/index_blueprint_collection_schema_all_of.rs index ce90bdb40c..a5db2ca21a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/index_blueprint_collection_schema_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/index_blueprint_collection_schema_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/indexed_state_schema.rs b/core-rust/core-api-server/src/core_api/generated/models/indexed_state_schema.rs index cbb6dc6242..66d639b01b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/indexed_state_schema.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/indexed_state_schema.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/instance_schema_blueprint_type_reference.rs b/core-rust/core-api-server/src/core_api/generated/models/instance_schema_blueprint_type_reference.rs index 1c3acf69f2..4c4d15768b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/instance_schema_blueprint_type_reference.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/instance_schema_blueprint_type_reference.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/instance_schema_blueprint_type_reference_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/instance_schema_blueprint_type_reference_all_of.rs index 915b255ad3..6f7c2e4e13 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/instance_schema_blueprint_type_reference_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/instance_schema_blueprint_type_reference_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/instant.rs b/core-rust/core-api-server/src/core_api/generated/models/instant.rs index 4f93a1d216..d5b84804d0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/instant.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/instant.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/instruction_resource_changes.rs b/core-rust/core-api-server/src/core_api/generated/models/instruction_resource_changes.rs index 825cffc2f4..b8a945d9b9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/instruction_resource_changes.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/instruction_resource_changes.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/key_value_based_structure.rs b/core-rust/core-api-server/src/core_api/generated/models/key_value_based_structure.rs index c675dcbbce..7cbbd10030 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/key_value_based_structure.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/key_value_based_structure.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/key_value_blueprint_collection_schema.rs b/core-rust/core-api-server/src/core_api/generated/models/key_value_blueprint_collection_schema.rs index 5774de08a1..9dfd4c065d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/key_value_blueprint_collection_schema.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/key_value_blueprint_collection_schema.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/key_value_blueprint_collection_schema_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/key_value_blueprint_collection_schema_all_of.rs index 8c721aaa56..a6cf2d385f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/key_value_blueprint_collection_schema_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/key_value_blueprint_collection_schema_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_entry_structure.rs b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_entry_structure.rs index a1dc30c4bc..d1fbf74f98 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_entry_structure.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_entry_structure.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_entry_structure_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_entry_structure_all_of.rs index 079c606901..05dbc46268 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_entry_structure_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_entry_structure_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_info.rs b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_info.rs index 2507fc0033..d10a15f915 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_info.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_info.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_type_info_details.rs b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_type_info_details.rs index 71c4ac088f..1975cbe41a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_type_info_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_type_info_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_type_info_details_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_type_info_details_all_of.rs index 921e89e027..cbbbf8db12 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/key_value_store_type_info_details_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/key_value_store_type_info_details_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/leader_proposal_history.rs b/core-rust/core-api-server/src/core_api/generated/models/leader_proposal_history.rs index 8345cd80d2..facbd91b60 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/leader_proposal_history.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/leader_proposal_history.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ledger_hashes.rs b/core-rust/core-api-server/src/core_api/generated/models/ledger_hashes.rs index c4a4f69e7f..e79134d618 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ledger_hashes.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ledger_hashes.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ledger_header.rs b/core-rust/core-api-server/src/core_api/generated/models/ledger_header.rs index fcbbc06d17..a965106c37 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ledger_header.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ledger_header.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ledger_header_summary.rs b/core-rust/core-api-server/src/core_api/generated/models/ledger_header_summary.rs index 705e253e6e..a75a2f645a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ledger_header_summary.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ledger_header_summary.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ledger_proof.rs b/core-rust/core-api-server/src/core_api/generated/models/ledger_proof.rs index 15dcccd7fd..fb40615564 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ledger_proof.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ledger_proof.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ledger_proof_origin.rs b/core-rust/core-api-server/src/core_api/generated/models/ledger_proof_origin.rs index 98e0db81f0..d5106631fd 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ledger_proof_origin.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ledger_proof_origin.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ledger_proof_origin_type.rs b/core-rust/core-api-server/src/core_api/generated/models/ledger_proof_origin_type.rs index 781af76f3c..8b7f9c5918 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ledger_proof_origin_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ledger_proof_origin_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ledger_state_summary.rs b/core-rust/core-api-server/src/core_api/generated/models/ledger_state_summary.rs index b2825df556..8e5f299729 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ledger_state_summary.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ledger_state_summary.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ledger_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/ledger_transaction.rs index 12258c0776..f3b41ab417 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ledger_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ledger_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/ledger_transaction_type.rs b/core-rust/core-api-server/src/core_api/generated/models/ledger_transaction_type.rs index c4f44ca4cd..fb7853cb4c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/ledger_transaction_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/ledger_transaction_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/local_generic_substitution.rs b/core-rust/core-api-server/src/core_api/generated/models/local_generic_substitution.rs index 28336c1545..83e23a22e2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/local_generic_substitution.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/local_generic_substitution.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/local_generic_substitution_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/local_generic_substitution_all_of.rs index 782c0228f7..76895d1e51 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/local_generic_substitution_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/local_generic_substitution_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/local_non_fungible_key.rs b/core-rust/core-api-server/src/core_api/generated/models/local_non_fungible_key.rs index 559c11443d..a4f6726f07 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/local_non_fungible_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/local_non_fungible_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/local_type_id.rs b/core-rust/core-api-server/src/core_api/generated/models/local_type_id.rs index 6c6a4d015e..af472a895a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/local_type_id.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/local_type_id.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_committed_transaction_outcome.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_committed_transaction_outcome.rs index d3d3d2d6e9..745de6f268 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_committed_transaction_outcome.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_committed_transaction_outcome.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_committed_transaction_status.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_committed_transaction_status.rs index 4951d6baca..335af3d720 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_committed_transaction_status.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_committed_transaction_status.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_entity_fungible_balance_changes.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_entity_fungible_balance_changes.rs index deb898bd43..2428196986 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_entity_fungible_balance_changes.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_entity_fungible_balance_changes.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_entity_non_fungible_balance_changes.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_entity_non_fungible_balance_changes.rs index cfc1b9b5de..afcd9d38a7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_entity_non_fungible_balance_changes.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_entity_non_fungible_balance_changes.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_fee_fungible_resource_balance_change.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_fee_fungible_resource_balance_change.rs index afc5ea84d1..2e279ec72a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_fee_fungible_resource_balance_change.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_fee_fungible_resource_balance_change.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_fee_fungible_resource_balance_change_type.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_fee_fungible_resource_balance_change_type.rs index 40d1d6cbb5..32d02483ca 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_fee_fungible_resource_balance_change_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_fee_fungible_resource_balance_change_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_fungible_resource_balance.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_fungible_resource_balance.rs index d42bf2322b..6d367df041 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_fungible_resource_balance.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_fungible_resource_balance.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_fungible_resource_balance_change.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_fungible_resource_balance_change.rs index 486e3ecdd7..aad55acc7c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_fungible_resource_balance_change.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_fungible_resource_balance_change.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_resultant_account_fungible_balances.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_resultant_account_fungible_balances.rs index b1371bdf33..f0aabf5b05 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_resultant_account_fungible_balances.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_resultant_account_fungible_balances.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_resultant_fungible_balance.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_resultant_fungible_balance.rs index ac2e273e38..47eb78ee18 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_resultant_fungible_balance.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_resultant_fungible_balance.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_all_fungible_resource_balances_request.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_all_fungible_resource_balances_request.rs index 3841c4e0ad..24fbe9f1ee 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_all_fungible_resource_balances_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_all_fungible_resource_balances_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_all_fungible_resource_balances_response.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_all_fungible_resource_balances_response.rs index fd81739832..dfca634aea 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_all_fungible_resource_balances_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_all_fungible_resource_balances_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_deposit_behaviour_request.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_deposit_behaviour_request.rs index d295005d3c..6677205033 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_deposit_behaviour_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_deposit_behaviour_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_deposit_behaviour_response.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_deposit_behaviour_response.rs index 819916d889..bddae12cb6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_deposit_behaviour_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_deposit_behaviour_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_fungible_resource_balance_request.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_fungible_resource_balance_request.rs index 6b737e81c4..60cdaa6a88 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_fungible_resource_balance_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_fungible_resource_balance_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_fungible_resource_balance_response.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_fungible_resource_balance_response.rs index 461539fa08..314fdc5eae 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_fungible_resource_balance_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_state_account_fungible_resource_balance_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_stream_account_transaction_outcomes_request.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_stream_account_transaction_outcomes_request.rs index 137dd31014..6ab1bdb3cd 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_stream_account_transaction_outcomes_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_stream_account_transaction_outcomes_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_stream_account_transaction_outcomes_response.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_stream_account_transaction_outcomes_response.rs index 80771fd45d..6e0c033881 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_stream_account_transaction_outcomes_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_stream_account_transaction_outcomes_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_stream_transaction_outcomes_request.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_stream_transaction_outcomes_request.rs index a838c0a030..ab4a386156 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_stream_transaction_outcomes_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_stream_transaction_outcomes_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_stream_transaction_outcomes_response.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_stream_transaction_outcomes_response.rs index ddc5fa7b10..5154aa5825 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_stream_transaction_outcomes_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_stream_transaction_outcomes_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_construction_request.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_construction_request.rs index 1974be40ec..ab8849d0b9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_construction_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_construction_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_construction_response.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_construction_response.rs index 5d0c1369a2..86db44ac48 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_construction_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_construction_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_intent_status.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_intent_status.rs index 15659511c2..e3cdab7c0e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_intent_status.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_intent_status.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_payload_details.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_payload_details.rs index d94ff3c160..f13f5f85b7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_payload_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_payload_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_payload_status.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_payload_status.rs index 80c51b50aa..ec284223d8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_payload_status.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_payload_status.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_status_request.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_status_request.rs index e102173196..435d116bca 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_status_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_status_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_status_response.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_status_response.rs index fe5554b18a..71929e8366 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_status_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_status_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_details.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_details.rs index dcc909ffb8..3c36d4392f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_details_type.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_details_type.rs index 8f468a952f..8976e8210d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_details_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_details_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_response.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_response.rs index e4ccd6e86d..d0dcf42746 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_response_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_response_all_of.rs index ad44fd3370..8ecb2ede6e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_response_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_error_response_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_intent_already_committed.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_intent_already_committed.rs index 953dab992f..5d120f9791 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_intent_already_committed.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_intent_already_committed.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_intent_already_committed_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_intent_already_committed_all_of.rs index e5bc7a26e1..e3e678a897 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_intent_already_committed_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_intent_already_committed_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_priority_threshold_not_met_error_details.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_priority_threshold_not_met_error_details.rs index ab15619526..5bacdfcb87 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_priority_threshold_not_met_error_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_priority_threshold_not_met_error_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_priority_threshold_not_met_error_details_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_priority_threshold_not_met_error_details_all_of.rs index e9620be283..51a121d6d3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_priority_threshold_not_met_error_details_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_priority_threshold_not_met_error_details_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_rejected_error_details.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_rejected_error_details.rs index bbe18a8ef0..aee7ff7de7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_rejected_error_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_rejected_error_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_rejected_error_details_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_rejected_error_details_all_of.rs index f793599274..4369930a0e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_rejected_error_details_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_rejected_error_details_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_request.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_request.rs index ac124973b5..907965943b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_response.rs b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_response.rs index 20df29cd67..53357b6c24 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/lts_transaction_submit_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/main_method_key.rs b/core-rust/core-api-server/src/core_api/generated/models/main_method_key.rs index fe580d7c5f..7387048ef6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/main_method_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/main_method_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/map_substate_key.rs b/core-rust/core-api-server/src/core_api/generated/models/map_substate_key.rs index 572631d862..7aa6d9c719 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/map_substate_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/map_substate_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/map_substate_key_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/map_substate_key_all_of.rs index 7989a0d98e..f63651b7a6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/map_substate_key_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/map_substate_key_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/mempool_list_request.rs b/core-rust/core-api-server/src/core_api/generated/models/mempool_list_request.rs index 444c99079f..66eccd64f6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/mempool_list_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/mempool_list_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/mempool_list_response.rs b/core-rust/core-api-server/src/core_api/generated/models/mempool_list_response.rs index c33022bf2d..b9239cb075 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/mempool_list_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/mempool_list_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_hashes.rs b/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_hashes.rs index 0d0853f418..13c64b174c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_hashes.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_hashes.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_request.rs b/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_request.rs index 25200283d6..1969743f78 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_response.rs b/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_response.rs index 700b274589..c916e5f7eb 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_response_payloads_inner.rs b/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_response_payloads_inner.rs index ed45d83ccf..955ec2d197 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_response_payloads_inner.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/mempool_transaction_response_payloads_inner.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/metadata_key.rs b/core-rust/core-api-server/src/core_api/generated/models/metadata_key.rs index 266b009e0c..e75e312a3e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/metadata_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/metadata_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_substate.rs index 20c5651633..497f4682d9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_substate_all_of.rs index fb97fac56d..6debf56ed8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_value.rs index f37e1f098b..c09ca18990 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/metadata_module_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/method_accessibility.rs b/core-rust/core-api-server/src/core_api/generated/models/method_accessibility.rs index 5acb02c75c..5dcf5ea1ea 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/method_accessibility.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/method_accessibility.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/method_accessibility_type.rs b/core-rust/core-api-server/src/core_api/generated/models/method_accessibility_type.rs index 91a2161bf2..dc48b32517 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/method_accessibility_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/method_accessibility_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/method_auth_type.rs b/core-rust/core-api-server/src/core_api/generated/models/method_auth_type.rs index a0d157b36d..3203dffdc5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/method_auth_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/method_auth_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/method_event_emitter_identifier.rs b/core-rust/core-api-server/src/core_api/generated/models/method_event_emitter_identifier.rs index 1809ce7758..0164bdbd4b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/method_event_emitter_identifier.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/method_event_emitter_identifier.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/method_event_emitter_identifier_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/method_event_emitter_identifier_all_of.rs index 37e841327c..831d62e2b0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/method_event_emitter_identifier_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/method_event_emitter_identifier_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/module_id.rs b/core-rust/core-api-server/src/core_api/generated/models/module_id.rs index ab48afaac7..58701869a7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/module_id.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/module_id.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/module_version.rs b/core-rust/core-api-server/src/core_api/generated/models/module_version.rs index 99e9b5d7e3..62760095a9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/module_version.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/module_version.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_substate.rs index 10905fd351..d8c28eefd7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_substate_all_of.rs index 92e2b0c01a..ed837f2c97 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_value.rs index c2642c5d28..0c64e0b077 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/multi_resource_pool_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/mutable_field.rs b/core-rust/core-api-server/src/core_api/generated/models/mutable_field.rs index 75f826a8fc..da39e853a5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/mutable_field.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/mutable_field.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response.rs b/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response.rs index 3073d99bb8..eb36ec920b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response_version.rs b/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response_version.rs index 3580436505..aac152a710 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response_version.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response_version.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response_well_known_addresses.rs b/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response_well_known_addresses.rs index a7a5625a61..833f30e6ac 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response_well_known_addresses.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/network_configuration_response_well_known_addresses.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/network_status_request.rs b/core-rust/core-api-server/src/core_api/generated/models/network_status_request.rs index 0fc9389648..dfab7a5777 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/network_status_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/network_status_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/network_status_response.rs b/core-rust/core-api-server/src/core_api/generated/models/network_status_response.rs index d0f55c91b6..726e979083 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/network_status_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/network_status_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/next_epoch.rs b/core-rust/core-api-server/src/core_api/generated/models/next_epoch.rs index b5cfbbe396..6daf7db62b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/next_epoch.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/next_epoch.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_authorized_depositor_badge.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_authorized_depositor_badge.rs index 8350ea1339..8c6160ea64 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_authorized_depositor_badge.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_authorized_depositor_badge.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_authorized_depositor_badge_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_authorized_depositor_badge_all_of.rs index ec80302288..0235499885 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_authorized_depositor_badge_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_authorized_depositor_badge_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_global_id.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_global_id.rs index caf5f07306..2d917de3e1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_global_id.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_global_id.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_id_type.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_id_type.rs index ba89d81e1d..8e56374834 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_id_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_id_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_local_id.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_local_id.rs index 41de0cf48b..0cd44a0f2b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_local_id.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_local_id.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_presented_badge.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_presented_badge.rs index 4ec630e0dd..761f92de24 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_presented_badge.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_presented_badge.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_presented_badge_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_presented_badge_all_of.rs index 2bbe1da469..1770bacc3f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_presented_badge_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_presented_badge_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_requirement.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_requirement.rs index c30a7628fb..feedc2dc55 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_requirement.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_requirement.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_requirement_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_requirement_all_of.rs index e4089b9c22..4ddae4f22a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_requirement_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_requirement_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_amount.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_amount.rs index 5a21e0dc06..81532abf6d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_amount.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_amount.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_amount_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_amount_all_of.rs index e8486ba77b..fcdf1af9cd 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_amount_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_amount_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_substate.rs index b4a6820d0b..3d4c2fee40 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_substate_all_of.rs index d414771be5..000affd406 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_value.rs index 3240f0f2aa..06307ababe 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_data_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_substate.rs index 7c82cda6f9..7ee94e6bd1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_substate_all_of.rs index a4a5e33eb9..84641cd3c0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_value.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_value.rs index 6c75fbd3cc..939b626ae9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_id_type_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_substate.rs index 3eaf2a3040..ee1364cba4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_substate_all_of.rs index 7212fcb6cb..c1a167dc6c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_value.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_value.rs index af3660794d..7996576f05 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_mutable_fields_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_substate.rs index 0db3f69f2f..ce7b401ab5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_substate_all_of.rs index 8b054f801e..2f8477653b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_value.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_value.rs index 6e1afe8476..fbe60e4dac 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_resource_manager_field_total_supply_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_substate.rs index ae79b4009b..e6675d5411 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_substate_all_of.rs index 099d2d5322..c360b9407f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_value.rs index dc67958e77..1185d59fa2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_contents_index_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_substate.rs index 8bd49cbec1..f695afc9a8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_substate_all_of.rs index ec04182079..da8f296616 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_value.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_value.rs index 8254f537b8..65df48945d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_balance_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_substate.rs index febf2b4bc0..2bd46a845d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_substate_all_of.rs index ffed250aea..e9c8352c4e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_value.rs b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_value.rs index 74cb0bd624..e51a05ca6f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/non_fungible_vault_field_frozen_status_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/notarized_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/notarized_transaction.rs index 5258187c06..01b22ba311 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/notarized_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/notarized_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_field_structure.rs b/core-rust/core-api-server/src/core_api/generated/models/object_field_structure.rs index 7d06ac22e8..945541ed23 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_field_structure.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_field_structure.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_field_structure_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/object_field_structure_all_of.rs index f632755abd..8de187d1be 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_field_structure_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_field_structure_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_hook.rs b/core-rust/core-api-server/src/core_api/generated/models/object_hook.rs index d64704612e..52733bb56f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_hook.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_hook.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_index_partition_entry_structure.rs b/core-rust/core-api-server/src/core_api/generated/models/object_index_partition_entry_structure.rs index b1e5093a00..6915f2a601 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_index_partition_entry_structure.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_index_partition_entry_structure.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_instance_type_reference.rs b/core-rust/core-api-server/src/core_api/generated/models/object_instance_type_reference.rs index 3a501c766a..668cb71c53 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_instance_type_reference.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_instance_type_reference.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_instance_type_reference_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/object_instance_type_reference_all_of.rs index b6847781db..ee993186c2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_instance_type_reference_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_instance_type_reference_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_key_value_partition_entry_structure.rs b/core-rust/core-api-server/src/core_api/generated/models/object_key_value_partition_entry_structure.rs index 8f36e133d6..0439bff39f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_key_value_partition_entry_structure.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_key_value_partition_entry_structure.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_role_key.rs b/core-rust/core-api-server/src/core_api/generated/models/object_role_key.rs index 15ba6018af..ea4e5b2bd4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_role_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_role_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_sorted_index_partition_entry_structure.rs b/core-rust/core-api-server/src/core_api/generated/models/object_sorted_index_partition_entry_structure.rs index 161b08840f..686c8e969e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_sorted_index_partition_entry_structure.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_sorted_index_partition_entry_structure.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_substate_type_reference.rs b/core-rust/core-api-server/src/core_api/generated/models/object_substate_type_reference.rs index 3a254778da..0d3c86c963 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_substate_type_reference.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_substate_type_reference.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_substate_type_reference_type.rs b/core-rust/core-api-server/src/core_api/generated/models/object_substate_type_reference_type.rs index 49a0f42c62..1bbe042bc6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_substate_type_reference_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_substate_type_reference_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_type_info_details.rs b/core-rust/core-api-server/src/core_api/generated/models/object_type_info_details.rs index 3706335804..60c3afd696 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_type_info_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_type_info_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/object_type_info_details_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/object_type_info_details_all_of.rs index 217dbec92a..96f29a1ecc 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/object_type_info_details_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/object_type_info_details_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_substate.rs index b4010f2d08..9f043e0cf1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_substate_all_of.rs index 95b6d0862a..f030049a84 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_value.rs index f3672d9b09..f5b3f8fd2b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/one_resource_pool_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/outer_object_only_method_accessibility.rs b/core-rust/core-api-server/src/core_api/generated/models/outer_object_only_method_accessibility.rs index 22f702efc5..96fdfcc242 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/outer_object_only_method_accessibility.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/outer_object_only_method_accessibility.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/own_package_only_method_accessibility.rs b/core-rust/core-api-server/src/core_api/generated/models/own_package_only_method_accessibility.rs index 4cb50c6859..2471a4fdc4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/own_package_only_method_accessibility.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/own_package_only_method_accessibility.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/owner_role.rs b/core-rust/core-api-server/src/core_api/generated/models/owner_role.rs index 7d2d7b5d09..7cb043dafc 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/owner_role.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/owner_role.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/owner_role_updater.rs b/core-rust/core-api-server/src/core_api/generated/models/owner_role_updater.rs index 0ac1ed7d10..0463b6b998 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/owner_role_updater.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/owner_role_updater.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_substate.rs index 21c41f086f..a385a5fec7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_substate_all_of.rs index 5e29b200db..82869dde36 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_value.rs index 10901a5324..f34f859551 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_auth_template_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_substate.rs index a84fbc2940..599f362bac 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_substate_all_of.rs index c88d89934b..59fa5752b0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_value.rs index 896dc5dae2..c69f43ef2e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_definition_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_substate.rs index 053d14adae..9e60c8ec45 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_substate_all_of.rs index e318b45051..1417c9264f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_value.rs index 0567bdf0ca..5111f38117 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_dependencies_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_substate.rs index 28e57b2bd5..ac43c14386 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_substate_all_of.rs index a23e884a69..f5dae42f55 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_value.rs index ebf0da0628..9fe306092f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_blueprint_royalty_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_substate.rs index 507c64d744..58131ff657 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_substate_all_of.rs index 837b8532d1..0d94700c22 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_value.rs index 576f913f7f..0877087c65 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_instrumented_code_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_key.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_key.rs index 0c3745fde8..b962651d65 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_substate.rs index 5b0c9bf8ce..bcb4244e89 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_substate_all_of.rs index 592043abce..5cf81a9aa8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_value.rs index b6ecc1b8fa..d3f208823d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_original_code_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_substate.rs index 526a7205cb..264b28eba7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_substate_all_of.rs index 0067eb83aa..4131ff7c6c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_value.rs index 7376e2fcaa..24d1b77128 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_code_vm_type_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_export.rs b/core-rust/core-api-server/src/core_api/generated/models/package_export.rs index 46ddf246bd..932bf75720 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_export.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_export.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_substate.rs index 0e607d81fc..a34e359cc5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_substate_all_of.rs index dcac7cb47e..afceb5a51b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_value.rs b/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_value.rs index 647f233559..ccf6241b3b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_field_royalty_accumulator_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_object_substate_type_reference.rs b/core-rust/core-api-server/src/core_api/generated/models/package_object_substate_type_reference.rs index 8853ef5c02..d0b2faaeab 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_object_substate_type_reference.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_object_substate_type_reference.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/package_type_reference.rs b/core-rust/core-api-server/src/core_api/generated/models/package_type_reference.rs index 97448aaf7e..0365c43c02 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/package_type_reference.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/package_type_reference.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction.rs index 439065001f..007bfd7378 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction_all_of.rs index 4e97f5e29f..df7610f675 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction_identifiers.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction_identifiers.rs index 7de6f2b75b..1116ff1e26 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction_identifiers.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_ledger_transaction_identifiers.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction.rs index 4f7e6b34c6..eb18d65170 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_all_of.rs index 6aac0b7600..56e5545217 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_all_of_validation_error.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_all_of_validation_error.rs index 428c3ce9cc..3f81a1549e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_all_of_validation_error.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_all_of_validation_error.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_identifiers.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_identifiers.rs index 0167e25401..59265f10a4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_identifiers.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_notarized_transaction_identifiers.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent.rs index 7c92e72890..6be461b7b8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent_all_of.rs index ce05aff194..1c8d318c93 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent_identifiers.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent_identifiers.rs index 55db52cd92..1eb3ae6bcc 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent_identifiers.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_signed_transaction_intent_identifiers.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction.rs index 6d0a5faa71..2065310952 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent.rs index 52ad04e252..d938c81d27 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent_all_of.rs index a340f3798c..ec3f2d82e3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent_identifiers.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent_identifiers.rs index 981374173f..4cd90bbe00 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent_identifiers.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_intent_identifiers.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_type.rs b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_type.rs index 6d39a0c5e6..bbde76e14b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/parsed_transaction_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/partition_description.rs b/core-rust/core-api-server/src/core_api/generated/models/partition_description.rs index a3c7ebba03..359742b278 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/partition_description.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/partition_description.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/partition_description_type.rs b/core-rust/core-api-server/src/core_api/generated/models/partition_description_type.rs index 091cbf18a0..911d3c5d59 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/partition_description_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/partition_description_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/partition_id.rs b/core-rust/core-api-server/src/core_api/generated/models/partition_id.rs index 1178ccb801..aa1acd0ccd 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/partition_id.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/partition_id.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/partition_kind.rs b/core-rust/core-api-server/src/core_api/generated/models/partition_kind.rs index 5b0367131b..2f59ef8c18 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/partition_kind.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/partition_kind.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/payment_from_vault.rs b/core-rust/core-api-server/src/core_api/generated/models/payment_from_vault.rs index 749e72a04b..7b4306dc39 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/payment_from_vault.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/payment_from_vault.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/payment_to_royalty_recipient.rs b/core-rust/core-api-server/src/core_api/generated/models/payment_to_royalty_recipient.rs index 435e968362..ae1cff39f0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/payment_to_royalty_recipient.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/payment_to_royalty_recipient.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/pending_owner_stake_withdrawal.rs b/core-rust/core-api-server/src/core_api/generated/models/pending_owner_stake_withdrawal.rs index 09f4c2a75d..f62bc52e70 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/pending_owner_stake_withdrawal.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/pending_owner_stake_withdrawal.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/plaintext_message_content.rs b/core-rust/core-api-server/src/core_api/generated/models/plaintext_message_content.rs index 02356a64db..98e30d6852 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/plaintext_message_content.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/plaintext_message_content.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/plaintext_message_content_type.rs b/core-rust/core-api-server/src/core_api/generated/models/plaintext_message_content_type.rs index 2db3361745..40e371d4e0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/plaintext_message_content_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/plaintext_message_content_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/plaintext_transaction_message.rs b/core-rust/core-api-server/src/core_api/generated/models/plaintext_transaction_message.rs index 6d5c3b03f9..f1581857bb 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/plaintext_transaction_message.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/plaintext_transaction_message.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/plaintext_transaction_message_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/plaintext_transaction_message_all_of.rs index b6e36e3fd4..1d7766d494 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/plaintext_transaction_message_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/plaintext_transaction_message_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/pool_vault.rs b/core-rust/core-api-server/src/core_api/generated/models/pool_vault.rs index c6de1a2bef..f14a92b9b4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/pool_vault.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/pool_vault.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/presented_badge.rs b/core-rust/core-api-server/src/core_api/generated/models/presented_badge.rs index 695c12fb3d..f1451d2ed7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/presented_badge.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/presented_badge.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/presented_badge_type.rs b/core-rust/core-api-server/src/core_api/generated/models/presented_badge_type.rs index 365fbc97d9..3d230087c9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/presented_badge_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/presented_badge_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/primary_role_recovery_attempt.rs b/core-rust/core-api-server/src/core_api/generated/models/primary_role_recovery_attempt.rs index fcf34981d3..e82a3738ba 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/primary_role_recovery_attempt.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/primary_role_recovery_attempt.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/proof_access_rule_node.rs b/core-rust/core-api-server/src/core_api/generated/models/proof_access_rule_node.rs index bb173ebce6..a366e487fb 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/proof_access_rule_node.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/proof_access_rule_node.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/proof_access_rule_node_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/proof_access_rule_node_all_of.rs index f3150f1513..3dd3a98f70 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/proof_access_rule_node_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/proof_access_rule_node_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/proof_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/proof_rule.rs index b67e39acc9..d87a8c4e4c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/proof_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/proof_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/proof_rule_type.rs b/core-rust/core-api-server/src/core_api/generated/models/proof_rule_type.rs index 0369779c10..972f0876fd 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/proof_rule_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/proof_rule_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/proposer_reward.rs b/core-rust/core-api-server/src/core_api/generated/models/proposer_reward.rs index cc459c2808..18466d77bb 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/proposer_reward.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/proposer_reward.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/protected_access_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/protected_access_rule.rs index 8c1220fea9..3e5a9b9ac4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/protected_access_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/protected_access_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/protected_access_rule_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/protected_access_rule_all_of.rs index 8b21132c17..8a39610d5e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/protected_access_rule_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/protected_access_rule_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/protocol_update_ledger_proof_origin.rs b/core-rust/core-api-server/src/core_api/generated/models/protocol_update_ledger_proof_origin.rs index bb1266623f..34ad3badf1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/protocol_update_ledger_proof_origin.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/protocol_update_ledger_proof_origin.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/protocol_update_ledger_proof_origin_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/protocol_update_ledger_proof_origin_all_of.rs index 15d6650ede..43b485e314 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/protocol_update_ledger_proof_origin_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/protocol_update_ledger_proof_origin_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/protocol_version_readiness.rs b/core-rust/core-api-server/src/core_api/generated/models/protocol_version_readiness.rs index b16d176eae..924fa69642 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/protocol_version_readiness.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/protocol_version_readiness.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/public_key.rs b/core-rust/core-api-server/src/core_api/generated/models/public_key.rs index fc85ccc91c..bfe8982f42 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/public_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/public_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/public_key_type.rs b/core-rust/core-api-server/src/core_api/generated/models/public_key_type.rs index 29cfb0cd3f..14aeaa5676 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/public_key_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/public_key_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/public_method_accessibility.rs b/core-rust/core-api-server/src/core_api/generated/models/public_method_accessibility.rs index 0b43cb5b8e..f4f5caf86b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/public_method_accessibility.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/public_method_accessibility.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/receiver_info.rs b/core-rust/core-api-server/src/core_api/generated/models/receiver_info.rs index 01c18841c1..b040233eea 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/receiver_info.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/receiver_info.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/recovery_proposal.rs b/core-rust/core-api-server/src/core_api/generated/models/recovery_proposal.rs index 628dc0d0bb..13f19d056b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/recovery_proposal.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/recovery_proposal.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/recovery_role_recovery_attempt.rs b/core-rust/core-api-server/src/core_api/generated/models/recovery_role_recovery_attempt.rs index da00117776..45fc8908a4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/recovery_role_recovery_attempt.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/recovery_role_recovery_attempt.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/reference_type.rs b/core-rust/core-api-server/src/core_api/generated/models/reference_type.rs index ba4521a9d4..97f6340731 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/reference_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/reference_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/remote_generic_substitution.rs b/core-rust/core-api-server/src/core_api/generated/models/remote_generic_substitution.rs index b9af8990ad..9ed327d7c8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/remote_generic_substitution.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/remote_generic_substitution.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/remote_generic_substitution_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/remote_generic_substitution_all_of.rs index 577452b7fb..d1dfa86d7c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/remote_generic_substitution_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/remote_generic_substitution_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/requested_state_version_out_of_bounds_error_details.rs b/core-rust/core-api-server/src/core_api/generated/models/requested_state_version_out_of_bounds_error_details.rs index f349f49fc5..333186193f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/requested_state_version_out_of_bounds_error_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/requested_state_version_out_of_bounds_error_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/require_proof_rule.rs b/core-rust/core-api-server/src/core_api/generated/models/require_proof_rule.rs index bc3ae0e1ef..f62671c5c5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/require_proof_rule.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/require_proof_rule.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/require_proof_rule_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/require_proof_rule_all_of.rs index b7f58d5eb6..a3fcd28b4e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/require_proof_rule_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/require_proof_rule_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/requirement.rs b/core-rust/core-api-server/src/core_api/generated/models/requirement.rs index 59e4285e8e..94ebd2a5d0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/requirement.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/requirement.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/requirement_type.rs b/core-rust/core-api-server/src/core_api/generated/models/requirement_type.rs index dcd1a29ab3..03f624c57c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/requirement_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/requirement_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_amount.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_amount.rs index 2f14abcc37..e307be279d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_amount.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_amount.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_authorized_depositor_badge.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_authorized_depositor_badge.rs index f95fbbb74d..f5bed8c3e1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_authorized_depositor_badge.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_authorized_depositor_badge.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_authorized_depositor_badge_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_authorized_depositor_badge_all_of.rs index d7a8fa311c..12c82ed437 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_authorized_depositor_badge_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_authorized_depositor_badge_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_change.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_change.rs index f575b0465c..df8056a68d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_change.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_change.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_key.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_key.rs index 8811cfc782..e1ac814123 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_preference.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_preference.rs index 7a15856bba..fa748063df 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_preference.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_preference.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_presented_badge.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_presented_badge.rs index e4294b82a2..62db969716 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_presented_badge.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_presented_badge.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_requirement.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_requirement.rs index d1430bb9e7..0f1591877b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_requirement.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_requirement.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_requirement_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_requirement_all_of.rs index c631bf087e..8017c684d4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_requirement_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_requirement_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_specific_deposit_behaviour.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_specific_deposit_behaviour.rs index a2519b4ffa..81db1d353d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_specific_deposit_behaviour.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_specific_deposit_behaviour.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/resource_type.rs b/core-rust/core-api-server/src/core_api/generated/models/resource_type.rs index d5799dfad9..8e535a56d8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/resource_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/resource_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_substate.rs index 5ee178ebd7..dcd8bb7320 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_substate_all_of.rs index 7e4b473847..f5b2509b3a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_value.rs b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_value.rs index 0e8935b9ba..99f0bd853d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_field_owner_role_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_substate.rs index e0904f050c..bd05bd7141 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_substate_all_of.rs index caee5b1148..42a7919992 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_value.rs index 5c2116ff25..cbfba46d27 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_assignment_module_rule_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_details.rs b/core-rust/core-api-server/src/core_api/generated/models/role_details.rs index e96e709ad9..bcab1797f7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_protected_method_accessibility.rs b/core-rust/core-api-server/src/core_api/generated/models/role_protected_method_accessibility.rs index d69ab31d7a..93d11e7649 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_protected_method_accessibility.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_protected_method_accessibility.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_protected_method_accessibility_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/role_protected_method_accessibility_all_of.rs index 08e8a4f801..8296b8906c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_protected_method_accessibility_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_protected_method_accessibility_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/role_specification.rs b/core-rust/core-api-server/src/core_api/generated/models/role_specification.rs index c2c5e54066..5a6cb849db 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/role_specification.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/role_specification.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/round_update_ledger_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/round_update_ledger_transaction.rs index 96bed5de7b..5acb4c86db 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/round_update_ledger_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/round_update_ledger_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/round_update_ledger_transaction_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/round_update_ledger_transaction_all_of.rs index ca36119925..c8ece4db14 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/round_update_ledger_transaction_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/round_update_ledger_transaction_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/round_update_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/round_update_transaction.rs index bdd8eba9c8..e3740f72c9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/round_update_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/round_update_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/royalty_amount.rs b/core-rust/core-api-server/src/core_api/generated/models/royalty_amount.rs index aaf92a5d00..004f0eddc4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/royalty_amount.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/royalty_amount.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_substate.rs index af635c87f5..86b851a710 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_substate_all_of.rs index 69ebc72567..964b770349 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_value.rs index 3bd667ea3b..f385749b29 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_substate.rs index 30dbdd58ff..657019ccf0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_substate_all_of.rs index 08fcf37eb7..b0bf25bd4c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_value.rs index 8f87ecac1e..6252226e0d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/royalty_module_method_royalty_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/sbor_data.rs b/core-rust/core-api-server/src/core_api/generated/models/sbor_data.rs index a3212814d5..3b5f258eaf 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/sbor_data.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/sbor_data.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/sbor_format_options.rs b/core-rust/core-api-server/src/core_api/generated/models/sbor_format_options.rs index ab1021f708..e529bcc1b9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/sbor_format_options.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/sbor_format_options.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/scenarios_request.rs b/core-rust/core-api-server/src/core_api/generated/models/scenarios_request.rs index 1ca2182ea5..80e1614290 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/scenarios_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/scenarios_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/scenarios_response.rs b/core-rust/core-api-server/src/core_api/generated/models/scenarios_response.rs index 924f8ca096..206ecfdcb2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/scenarios_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/scenarios_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/schema_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/schema_entry_substate.rs index 624d112dd1..f8af2bd99d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/schema_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/schema_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/schema_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/schema_entry_substate_all_of.rs index d8630f1abe..68de8ac58f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/schema_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/schema_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/schema_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/schema_entry_value.rs index c2df47466c..761dd4ac3b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/schema_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/schema_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/schema_key.rs b/core-rust/core-api-server/src/core_api/generated/models/schema_key.rs index c42cacf672..790933b55e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/schema_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/schema_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/scoped_type_id.rs b/core-rust/core-api-server/src/core_api/generated/models/scoped_type_id.rs index ee0e138f00..76abaebdd7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/scoped_type_id.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/scoped_type_id.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/scrypto_schema.rs b/core-rust/core-api-server/src/core_api/generated/models/scrypto_schema.rs index 0a616f5ae0..8b65b8b045 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/scrypto_schema.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/scrypto_schema.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/signalling_validator.rs b/core-rust/core-api-server/src/core_api/generated/models/signalling_validator.rs index bc07a83e0d..bc689507e3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/signalling_validator.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/signalling_validator.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/signature.rs b/core-rust/core-api-server/src/core_api/generated/models/signature.rs index 7ad9946956..eb22e33403 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/signature.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/signature.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/signature_with_public_key.rs b/core-rust/core-api-server/src/core_api/generated/models/signature_with_public_key.rs index baa706fdb6..0a442ee2eb 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/signature_with_public_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/signature_with_public_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/signed_transaction_intent.rs b/core-rust/core-api-server/src/core_api/generated/models/signed_transaction_intent.rs index ff0a6ec543..311cc32b88 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/signed_transaction_intent.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/signed_transaction_intent.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/significant_protocol_update_readiness_entry.rs b/core-rust/core-api-server/src/core_api/generated/models/significant_protocol_update_readiness_entry.rs index b1717cb846..c6905ad541 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/significant_protocol_update_readiness_entry.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/significant_protocol_update_readiness_entry.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/sorted_index_blueprint_collection_schema.rs b/core-rust/core-api-server/src/core_api/generated/models/sorted_index_blueprint_collection_schema.rs index 1892786f41..66cf06b291 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/sorted_index_blueprint_collection_schema.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/sorted_index_blueprint_collection_schema.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/sorted_index_blueprint_collection_schema_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/sorted_index_blueprint_collection_schema_all_of.rs index 3ff8c88b40..94019f090b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/sorted_index_blueprint_collection_schema_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/sorted_index_blueprint_collection_schema_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/sorted_substate_key.rs b/core-rust/core-api-server/src/core_api/generated/models/sorted_substate_key.rs index 9aba1b6884..1efd45910e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/sorted_substate_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/sorted_substate_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/sorted_substate_key_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/sorted_substate_key_all_of.rs index 26998414ff..7ce1315ca4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/sorted_substate_key_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/sorted_substate_key_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_access_controller_request.rs b/core-rust/core-api-server/src/core_api/generated/models/state_access_controller_request.rs index ede17dfffe..5194fc6fa9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_access_controller_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_access_controller_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_access_controller_response.rs b/core-rust/core-api-server/src/core_api/generated/models/state_access_controller_response.rs index d28fe0b795..ba8d59ddcf 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_access_controller_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_access_controller_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_account_request.rs b/core-rust/core-api-server/src/core_api/generated/models/state_account_request.rs index a64b5341f9..34244c8fe2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_account_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_account_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_account_response.rs b/core-rust/core-api-server/src/core_api/generated/models/state_account_response.rs index 7be2bcfc46..fb694572cb 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_account_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_account_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_component_descendent_node.rs b/core-rust/core-api-server/src/core_api/generated/models/state_component_descendent_node.rs index 6bd7f8fd4a..edefab489f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_component_descendent_node.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_component_descendent_node.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_component_request.rs b/core-rust/core-api-server/src/core_api/generated/models/state_component_request.rs index 4768c71fbd..fcc12ab212 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_component_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_component_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_component_response.rs b/core-rust/core-api-server/src/core_api/generated/models/state_component_response.rs index 16306a74a1..7ac6bfe6ba 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_component_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_component_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_consensus_manager_request.rs b/core-rust/core-api-server/src/core_api/generated/models/state_consensus_manager_request.rs index e193748a3f..222416ef6c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_consensus_manager_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_consensus_manager_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_consensus_manager_response.rs b/core-rust/core-api-server/src/core_api/generated/models/state_consensus_manager_response.rs index 2020e7d935..5db15ef4f7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_consensus_manager_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_consensus_manager_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_fungible_resource_manager.rs b/core-rust/core-api-server/src/core_api/generated/models/state_fungible_resource_manager.rs index cd2397ecfa..eadfcad3ff 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_fungible_resource_manager.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_fungible_resource_manager.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_fungible_resource_manager_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/state_fungible_resource_manager_all_of.rs index aadc002fba..bef905ddfa 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_fungible_resource_manager_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_fungible_resource_manager_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_request.rs b/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_request.rs index dbcfdd1d97..5b86dd314d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_resource_manager.rs b/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_resource_manager.rs index bb4b86365f..1388c35956 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_resource_manager.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_resource_manager.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_resource_manager_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_resource_manager_all_of.rs index b4e870b2e3..8af932c3ef 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_resource_manager_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_resource_manager_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_response.rs b/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_response.rs index 634fa25c34..7bf8536e39 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_non_fungible_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_package_request.rs b/core-rust/core-api-server/src/core_api/generated/models/state_package_request.rs index c4565a3774..054b8fe96b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_package_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_package_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_package_response.rs b/core-rust/core-api-server/src/core_api/generated/models/state_package_response.rs index 9f2854ed68..91cddd9e95 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_package_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_package_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_resource_manager.rs b/core-rust/core-api-server/src/core_api/generated/models/state_resource_manager.rs index 9da9730968..2de153f234 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_resource_manager.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_resource_manager.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_resource_request.rs b/core-rust/core-api-server/src/core_api/generated/models/state_resource_request.rs index f86135c1a1..6326447fd7 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_resource_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_resource_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_resource_response.rs b/core-rust/core-api-server/src/core_api/generated/models/state_resource_response.rs index 5ce589c4eb..6a76711b32 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_resource_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_resource_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_updates.rs b/core-rust/core-api-server/src/core_api/generated/models/state_updates.rs index baf15c0ba3..45d2f2e83c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_updates.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_updates.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_validator_request.rs b/core-rust/core-api-server/src/core_api/generated/models/state_validator_request.rs index 872df3e2db..9248696c9e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_validator_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_validator_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/state_validator_response.rs b/core-rust/core-api-server/src/core_api/generated/models/state_validator_response.rs index c5f1aacea0..e8597c64b0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/state_validator_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/state_validator_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/static_blueprint_payload_def.rs b/core-rust/core-api-server/src/core_api/generated/models/static_blueprint_payload_def.rs index cc7036ec2e..75ef7e3d22 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/static_blueprint_payload_def.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/static_blueprint_payload_def.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/static_blueprint_payload_def_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/static_blueprint_payload_def_all_of.rs index 610c698db1..b94172c28a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/static_blueprint_payload_def_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/static_blueprint_payload_def_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/static_role_definition_auth_template.rs b/core-rust/core-api-server/src/core_api/generated/models/static_role_definition_auth_template.rs index d955a49370..3604681996 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/static_role_definition_auth_template.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/static_role_definition_auth_template.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details.rs index 4dbdc08f80..32088b281c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_epoch_out_of_bounds.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_epoch_out_of_bounds.rs index 886dba0283..31dfb034d4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_epoch_out_of_bounds.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_epoch_out_of_bounds.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_epoch_out_of_bounds_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_epoch_out_of_bounds_all_of.rs index 00d9cdeda9..c1fad02d48 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_epoch_out_of_bounds_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_epoch_out_of_bounds_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_state_version_out_of_bounds.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_state_version_out_of_bounds.rs index 9b3a94d1ff..0bd5671ee5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_state_version_out_of_bounds.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_state_version_out_of_bounds.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_state_version_out_of_bounds_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_state_version_out_of_bounds_all_of.rs index d0bbefb882..aa7a0c9622 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_state_version_out_of_bounds_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_requested_state_version_out_of_bounds_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_type.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_type.rs index 1bb1b01813..568aaba77e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_details_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_response.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_response.rs index 361d90e412..dc74b7e3b0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_response_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_response_all_of.rs index e712e79039..b8bd10c3bb 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_response_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_error_response_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter.rs index 07b853a813..015bc884d9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_any.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_any.rs index e70434db7c..231fdba0a8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_any.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_any.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_any_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_any_all_of.rs index 8eec55a89c..24b4fc176a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_any_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_any_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_new_epochs.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_new_epochs.rs index e7537fcfd6..db619e7221 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_new_epochs.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_new_epochs.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_new_epochs_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_new_epochs_all_of.rs index d9f3973b65..230430fbb3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_new_epochs_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_new_epochs_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_execution.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_execution.rs index 7b5d65703d..b0a3840998 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_execution.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_execution.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_execution_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_execution_all_of.rs index 76e9693518..03cf94b872 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_execution_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_execution_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_initializations.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_initializations.rs index 6ad4c38ad8..2b6fbbd40e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_initializations.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_protocol_update_initializations.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_type.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_type.rs index 0889f80719..5194baf2da 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_filter_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_request.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_request.rs index 71ba7c439f..75462ff4ca 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_response.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_response.rs index ec5c865f42..d5afed15aa 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_proofs_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_details.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_details.rs index 9c164dcfd8..f681027be3 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_details_type.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_details_type.rs index 81e08f1870..f33abba576 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_details_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_details_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_response.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_response.rs index ac2c6c586f..0fc2eecfc9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_response_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_response_all_of.rs index d1068916ac..b2e89e844e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_response_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_error_response_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_request.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_request.rs index aa4ff2a34e..cc67851708 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_response.rs b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_response.rs index 1da1757340..0367862677 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/stream_transactions_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/string_plaintext_message_content.rs b/core-rust/core-api-server/src/core_api/generated/models/string_plaintext_message_content.rs index b7599c87cd..8d2030091e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/string_plaintext_message_content.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/string_plaintext_message_content.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/string_plaintext_message_content_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/string_plaintext_message_content_all_of.rs index 7a16afea66..ec3a87f3a0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/string_plaintext_message_content_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/string_plaintext_message_content_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate.rs b/core-rust/core-api-server/src/core_api/generated/models/substate.rs index c02871ece4..0b9ce16f23 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate_format_options.rs b/core-rust/core-api-server/src/core_api/generated/models/substate_format_options.rs index 62baabd18d..0b7ed5547f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate_format_options.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate_format_options.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate_id.rs b/core-rust/core-api-server/src/core_api/generated/models/substate_id.rs index 41902b358a..2fab01fb1d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate_id.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate_id.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate_id_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/substate_id_all_of.rs index cdd01cc559..796f6a430c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate_id_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate_id_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate_key.rs b/core-rust/core-api-server/src/core_api/generated/models/substate_key.rs index 0384a42910..c9b507bd9b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate_key_type.rs b/core-rust/core-api-server/src/core_api/generated/models/substate_key_type.rs index 2e42392c84..839de2baa6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate_key_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate_key_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate_system_structure.rs b/core-rust/core-api-server/src/core_api/generated/models/substate_system_structure.rs index ba8928b175..c093916610 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate_system_structure.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate_system_structure.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate_system_structure_type.rs b/core-rust/core-api-server/src/core_api/generated/models/substate_system_structure_type.rs index c612cb1b13..795b8c5d48 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate_system_structure_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate_system_structure_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate_type.rs b/core-rust/core-api-server/src/core_api/generated/models/substate_type.rs index c0e4859639..dba0010973 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/substate_value.rs b/core-rust/core-api-server/src/core_api/generated/models/substate_value.rs index 7497fbe92c..98b4fdd1ce 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/substate_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/substate_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/system_field_kind.rs b/core-rust/core-api-server/src/core_api/generated/models/system_field_kind.rs index de0a6f91f3..593d74e86f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/system_field_kind.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/system_field_kind.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/system_field_structure.rs b/core-rust/core-api-server/src/core_api/generated/models/system_field_structure.rs index 0a3b1e00e0..e0f600eab5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/system_field_structure.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/system_field_structure.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/system_field_structure_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/system_field_structure_all_of.rs index 5a9759cd41..aa7f76d2c5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/system_field_structure_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/system_field_structure_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/system_schema_structure.rs b/core-rust/core-api-server/src/core_api/generated/models/system_schema_structure.rs index 357431e921..ff5822abb5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/system_schema_structure.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/system_schema_structure.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/system_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/system_transaction.rs index 97e7cf7a35..c4b87254ce 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/system_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/system_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/target_identifier.rs b/core-rust/core-api-server/src/core_api/generated/models/target_identifier.rs index d705d99cbe..f1f7808cfe 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/target_identifier.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/target_identifier.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/target_identifier_type.rs b/core-rust/core-api-server/src/core_api/generated/models/target_identifier_type.rs index 0c4ee44400..c1fa65db3a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/target_identifier_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/target_identifier_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/timestamped_validator_signature.rs b/core-rust/core-api-server/src/core_api/generated/models/timestamped_validator_signature.rs index 7f4c620153..b48bebe9d9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/timestamped_validator_signature.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/timestamped_validator_signature.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_call_preview_request.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_call_preview_request.rs index 5a75a8372c..7c1a61345f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_call_preview_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_call_preview_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_call_preview_response.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_call_preview_response.rs index 6a00421da9..9200280d82 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_call_preview_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_call_preview_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_format_options.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_format_options.rs index 3b800a5534..01ff398313 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_format_options.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_format_options.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_header.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_header.rs index 299afd5263..4877943457 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_header.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_header.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_id_key.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_id_key.rs index 464c54967f..c561dfad7e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_id_key.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_id_key.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_identifiers.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_identifiers.rs index 7cbf342749..79f6b5cac9 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_identifiers.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_identifiers.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_intent.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_intent.rs index 43ddcaa68e..b2ca6e80f5 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_intent.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_intent.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_intent_status.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_intent_status.rs index 84d967edbe..fcc901c28b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_intent_status.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_intent_status.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_message.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_message.rs index 259c362e48..c72508f4a1 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_message.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_message.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_message_type.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_message_type.rs index d28482d675..d79144acf2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_message_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_message_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_parse_request.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_parse_request.rs index 73b781675e..a008914479 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_parse_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_parse_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_parse_response.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_parse_response.rs index e985dcdb84..57aa2c7489 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_parse_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_parse_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_payload_details.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_payload_details.rs index 2cfbd3144f..c09da03ecc 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_payload_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_payload_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_payload_status.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_payload_status.rs index 6a543665ba..1f3344ffa8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_payload_status.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_payload_status.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_request.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_request.rs index 82fc6714e5..9a8049304c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_request_flags.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_request_flags.rs index 80e42cf485..c51a3bf315 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_request_flags.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_request_flags.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_response.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_response.rs index 3c121a470c..c52d23a969 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_response_logs_inner.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_response_logs_inner.rs index c37decd238..ea9b785b42 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_response_logs_inner.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_preview_response_logs_inner.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt.rs index ff2de494a5..7bda088bec 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt_request.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt_request.rs index a3b3e002a6..bd44e895da 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt_response.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt_response.rs index aaff084480..589792b7dd 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_receipt_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_status.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_status.rs index b19e91fbf4..faf6fabc7d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_status.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_status.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_status_request.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_status_request.rs index becf49c8f9..1f47ec1b6b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_status_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_status_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_status_response.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_status_response.rs index 9fca185713..7e89f9e8e0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_status_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_status_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_details.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_details.rs index 94712fe242..9c0fbc14e0 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_details_type.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_details_type.rs index 923f90df77..144af2e580 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_details_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_details_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_response.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_response.rs index 86b6471bcd..7eb3e733c4 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_response_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_response_all_of.rs index c7fc259642..72b83664c2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_response_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_error_response_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_intent_already_committed.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_intent_already_committed.rs index 843e29028d..e5e9ea6096 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_intent_already_committed.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_intent_already_committed.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_priority_threshold_not_met_error_details.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_priority_threshold_not_met_error_details.rs index 7d3ac003be..931730826c 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_priority_threshold_not_met_error_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_priority_threshold_not_met_error_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_rejected_error_details.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_rejected_error_details.rs index 039b93e14a..e3bda6f16d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_rejected_error_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_rejected_error_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_request.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_request.rs index c51e6a0df6..5d085dd648 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_response.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_response.rs index a36e32905c..07b9e0b306 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_response.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_submit_response.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_substate.rs index e6fec4cb24..33c8846c3e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_substate_all_of.rs index 8609d81d7f..d536e24e08 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_value.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_value.rs index 9eec07102b..f6350c9231 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_collection_entry_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_substate.rs index 49c6c590ff..180000ff1b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_substate_all_of.rs index da92a517b6..7b262cae04 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_value.rs index 685ba80946..9d582d8784 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_transaction_status.rs b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_transaction_status.rs index eef9d9df26..de0f993a24 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_transaction_status.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/transaction_tracker_transaction_status.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_substate.rs index 4ebd12065d..282462d195 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_substate_all_of.rs index 73d644d7f7..6ab8dec83f 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_value.rs index ed7d8e84e7..3245a4e7bf 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/two_resource_pool_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/type_info_details.rs b/core-rust/core-api-server/src/core_api/generated/models/type_info_details.rs index a9a202cc65..4c4a994884 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/type_info_details.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/type_info_details.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_substate.rs index d216ae13cb..aa2fd4066a 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_substate_all_of.rs index 43af79c254..8b950eaf0e 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_value.rs b/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_value.rs index 67b653ddd5..c8c87d1ca2 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/type_info_module_field_type_info_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/type_info_type.rs b/core-rust/core-api-server/src/core_api/generated/models/type_info_type.rs index e645bcc840..b91cbc3061 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/type_info_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/type_info_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/updated_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/updated_substate.rs index 3a3ee02691..9aa320da34 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/updated_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/updated_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/user_ledger_transaction.rs b/core-rust/core-api-server/src/core_api/generated/models/user_ledger_transaction.rs index 3ec57f1bd7..4b2ba0e96d 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/user_ledger_transaction.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/user_ledger_transaction.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/user_ledger_transaction_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/user_ledger_transaction_all_of.rs index df450c0ec0..c2abc7b57b 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/user_ledger_transaction_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/user_ledger_transaction_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/validator_fee_change_request.rs b/core-rust/core-api-server/src/core_api/generated/models/validator_fee_change_request.rs index 054a10c3cb..c3ab35bb00 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/validator_fee_change_request.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/validator_fee_change_request.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_substate.rs index 37efacef67..73011b0bfc 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_substate_all_of.rs index fd02e55eca..70ceff70dd 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_value.rs b/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_value.rs index 6d6a0223ca..fd610d3999 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/validator_field_protocol_update_readiness_signal_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_substate.rs b/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_substate.rs index 99b3dd2ac4..cc05aa0882 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_substate.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_substate.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_substate_all_of.rs b/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_substate_all_of.rs index e44f968d54..7ac1defb59 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_substate_all_of.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_substate_all_of.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_value.rs b/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_value.rs index 7a2022f946..565b29c5b6 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_value.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/validator_field_state_value.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/vault_balance.rs b/core-rust/core-api-server/src/core_api/generated/models/vault_balance.rs index 869e301003..ab7195af72 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/vault_balance.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/vault_balance.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/virtual_lazy_load_schema.rs b/core-rust/core-api-server/src/core_api/generated/models/virtual_lazy_load_schema.rs index 0f1c56ad1c..b8ac53b115 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/virtual_lazy_load_schema.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/virtual_lazy_load_schema.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core-rust/core-api-server/src/core_api/generated/models/vm_type.rs b/core-rust/core-api-server/src/core_api/generated/models/vm_type.rs index 144aa12c4c..c2e6ee1cd8 100644 --- a/core-rust/core-api-server/src/core_api/generated/models/vm_type.rs +++ b/core-rust/core-api-server/src/core_api/generated/models/vm_type.rs @@ -1,9 +1,9 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * Generated by: https://openapi-generator.tech */ diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/Address.java b/core/src/main/java/com/radixdlt/api/system/generated/models/Address.java index edc91995eb..710dda2264 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/Address.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/Address.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/AddressBookEntry.java b/core/src/main/java/com/radixdlt/api/system/generated/models/AddressBookEntry.java index 8a55d6d75e..2f6149c9a1 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/AddressBookEntry.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/AddressBookEntry.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/BFTConfiguration.java b/core/src/main/java/com/radixdlt/api/system/generated/models/BFTConfiguration.java index 757ab69493..77d05fe7ca 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/BFTConfiguration.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/BFTConfiguration.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/EmptyPendingProtocolUpdateState.java b/core/src/main/java/com/radixdlt/api/system/generated/models/EmptyPendingProtocolUpdateState.java index c106deb4aa..e81c6077c7 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/EmptyPendingProtocolUpdateState.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/EmptyPendingProtocolUpdateState.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochIfValidatorsReadyCondition.java b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochIfValidatorsReadyCondition.java index 2adc3feaeb..4d89efbe9c 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochIfValidatorsReadyCondition.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochIfValidatorsReadyCondition.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochIfValidatorsReadyConditionAllOf.java b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochIfValidatorsReadyConditionAllOf.java index 0042892daa..2e2e143ec7 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochIfValidatorsReadyConditionAllOf.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochIfValidatorsReadyConditionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochUnconditionallyCondition.java b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochUnconditionallyCondition.java index 378f89a426..b3b5d4045c 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochUnconditionallyCondition.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochUnconditionallyCondition.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochUnconditionallyConditionAllOf.java b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochUnconditionallyConditionAllOf.java index 771c713ab9..e5ff605d9d 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochUnconditionallyConditionAllOf.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactAtStartOfEpochUnconditionallyConditionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactedProtocolUpdate.java b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactedProtocolUpdate.java index 3f4e6dfd1c..319c4e9662 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/EnactedProtocolUpdate.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/EnactedProtocolUpdate.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/Error.java b/core/src/main/java/com/radixdlt/api/system/generated/models/Error.java index bb03473616..4668cb07f2 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/Error.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/Error.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/HealthResponse.java b/core/src/main/java/com/radixdlt/api/system/generated/models/HealthResponse.java index 2128a5b337..842474ccca 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/HealthResponse.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/HealthResponse.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/IdentityResponse.java b/core/src/main/java/com/radixdlt/api/system/generated/models/IdentityResponse.java index 306615eee2..f9e9bf64f2 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/IdentityResponse.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/IdentityResponse.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/MempoolConfiguration.java b/core/src/main/java/com/radixdlt/api/system/generated/models/MempoolConfiguration.java index 697aff788d..c0dafc1688 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/MempoolConfiguration.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/MempoolConfiguration.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/NetworkSyncStatusResponse.java b/core/src/main/java/com/radixdlt/api/system/generated/models/NetworkSyncStatusResponse.java index a976d486eb..6718d98049 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/NetworkSyncStatusResponse.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/NetworkSyncStatusResponse.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/NetworkingConfiguration.java b/core/src/main/java/com/radixdlt/api/system/generated/models/NetworkingConfiguration.java index 89fa15d9f2..31cc717a6d 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/NetworkingConfiguration.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/NetworkingConfiguration.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/Peer.java b/core/src/main/java/com/radixdlt/api/system/generated/models/Peer.java index 0af52043fe..0bcb0e7d96 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/Peer.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/Peer.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/PeerApplicationVersion.java b/core/src/main/java/com/radixdlt/api/system/generated/models/PeerApplicationVersion.java index 6ff2645f4d..f70bc40e7a 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/PeerApplicationVersion.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/PeerApplicationVersion.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/PeerChannel.java b/core/src/main/java/com/radixdlt/api/system/generated/models/PeerChannel.java index 8944b2e1bd..66c892d3a5 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/PeerChannel.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/PeerChannel.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdate.java b/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdate.java index 2cd74aea68..0e6d0f9c88 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdate.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdate.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdateState.java b/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdateState.java index 95eb425c64..1957dfbaa7 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdateState.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdateState.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdateStateType.java b/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdateStateType.java index b0b9f48fe1..19a47c3f8b 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdateStateType.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/PendingProtocolUpdateStateType.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolConfiguration.java b/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolConfiguration.java index 2b980b08fb..b08de4c0ce 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolConfiguration.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolConfiguration.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateEnactmentCondition.java b/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateEnactmentCondition.java index ac360db666..a3c544f7b3 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateEnactmentCondition.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateEnactmentCondition.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateEnactmentConditionType.java b/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateEnactmentConditionType.java index 994ed96f69..0890d46bcd 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateEnactmentConditionType.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateEnactmentConditionType.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateTrigger.java b/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateTrigger.java index 9d04188a7d..239310ef34 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateTrigger.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/ProtocolUpdateTrigger.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/RecentSelfProposalMissStatistic.java b/core/src/main/java/com/radixdlt/api/system/generated/models/RecentSelfProposalMissStatistic.java index 9acb8c947a..83ae186a17 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/RecentSelfProposalMissStatistic.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/RecentSelfProposalMissStatistic.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateState.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateState.java index 043460865a..3458ceaaab 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateState.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateState.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateStateAllOf.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateStateAllOf.java index 9fc3210504..adf175fbb2 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateStateAllOf.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateStateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateStateAllOfThresholdsState.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateStateAllOfThresholdsState.java index 3961895934..1758dc7c41 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateStateAllOfThresholdsState.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessPendingProtocolUpdateStateAllOfThresholdsState.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessThreshold.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessThreshold.java index 692083b699..967a2c08d0 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessThreshold.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessThreshold.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessThresholdState.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessThresholdState.java index 1b466c8b5d..a669a84a31 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessThresholdState.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SignalledReadinessThresholdState.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SyncConfiguration.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SyncConfiguration.java index ac40b0e502..be66b2535a 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SyncConfiguration.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SyncConfiguration.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SyncStatus.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SyncStatus.java index e0e6cc7f22..a432109064 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SyncStatus.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SyncStatus.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SystemAddressBookResponse.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SystemAddressBookResponse.java index b9cd8b0b47..ba586b207b 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SystemAddressBookResponse.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SystemAddressBookResponse.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SystemConfigurationResponse.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SystemConfigurationResponse.java index 4f9d82a8c1..ce51f887de 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SystemConfigurationResponse.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SystemConfigurationResponse.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/SystemPeersResponse.java b/core/src/main/java/com/radixdlt/api/system/generated/models/SystemPeersResponse.java index 820bc9df72..e392c1458d 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/SystemPeersResponse.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/SystemPeersResponse.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/UnknownReportedPendingProtocolUpdate.java b/core/src/main/java/com/radixdlt/api/system/generated/models/UnknownReportedPendingProtocolUpdate.java index 925daa28ba..8d0c4f7062 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/UnknownReportedPendingProtocolUpdate.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/UnknownReportedPendingProtocolUpdate.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/generated/models/VersionResponse.java b/core/src/main/java/com/radixdlt/api/system/generated/models/VersionResponse.java index ad9bc077e7..774a09ca59 100644 --- a/core/src/main/java/com/radixdlt/api/system/generated/models/VersionResponse.java +++ b/core/src/main/java/com/radixdlt/api/system/generated/models/VersionResponse.java @@ -1,8 +1,8 @@ /* - * Radix System API - Babylon + * Radix System API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to information about the node itself, its configuration, status and subsystems. It is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Heavy load may impact the node's function. If you require queries against ledger state, you may also wish to consider using the [Core API or Gateway API instead](https://docs-babylon.radixdlt.com/main/apis/api-specification.html). * - * The version of the OpenAPI document: v1.0.0 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/main/java/com/radixdlt/api/system/system-api-schema.yaml b/core/src/main/java/com/radixdlt/api/system/system-api-schema.yaml index f67b471271..deaa90c80d 100644 --- a/core/src/main/java/com/radixdlt/api/system/system-api-schema.yaml +++ b/core/src/main/java/com/radixdlt/api/system/system-api-schema.yaml @@ -1,8 +1,8 @@ openapi: 3.0.0 info: # Should be the release version, and the release display name - version: 'v1.0.0' - title: 'Radix System API - Babylon' + version: 'v1.1.0' + title: 'Radix System API - Babylon (Anemone)' license: name: The Radix License, Version 1.0 url: https://www.radixfoundation.org/licenses/license-v1 diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/api/LtsApi.java b/core/src/test-core/java/com/radixdlt/api/core/generated/api/LtsApi.java index f9338a67e5..70c86ce205 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/api/LtsApi.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/api/LtsApi.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/api/MempoolApi.java b/core/src/test-core/java/com/radixdlt/api/core/generated/api/MempoolApi.java index c53efe624b..a106582dbd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/api/MempoolApi.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/api/MempoolApi.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/api/StateApi.java b/core/src/test-core/java/com/radixdlt/api/core/generated/api/StateApi.java index 886f48f36d..8f2c18cdb5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/api/StateApi.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/api/StateApi.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/api/StatusApi.java b/core/src/test-core/java/com/radixdlt/api/core/generated/api/StatusApi.java index cfa7e0aee5..9f8e3c14ae 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/api/StatusApi.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/api/StatusApi.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/api/StreamApi.java b/core/src/test-core/java/com/radixdlt/api/core/generated/api/StreamApi.java index 4af52a54eb..fcd1ce621c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/api/StreamApi.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/api/StreamApi.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/api/TransactionApi.java b/core/src/test-core/java/com/radixdlt/api/core/generated/api/TransactionApi.java index 821cdef19e..72c68ad59e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/api/TransactionApi.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/api/TransactionApi.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiClient.java b/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiClient.java index d7197c0ff5..2b7b113159 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiClient.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiClient.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiException.java b/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiException.java index 5f34b0ddd1..c3c5ae0f65 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiException.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiException.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiResponse.java index 4e5d6f7153..6f84733b71 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/client/ApiResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/client/Configuration.java b/core/src/test-core/java/com/radixdlt/api/core/generated/client/Configuration.java index c968143c22..d5dff13b4d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/client/Configuration.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/client/Configuration.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/client/Pair.java b/core/src/test-core/java/com/radixdlt/api/core/generated/client/Pair.java index 9b211cd127..0143c15750 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/client/Pair.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/client/Pair.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/client/RFC3339DateFormat.java b/core/src/test-core/java/com/radixdlt/api/core/generated/client/RFC3339DateFormat.java index 94ae2c7423..a441d66b6f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/client/RFC3339DateFormat.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/client/RFC3339DateFormat.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AbstractOpenApiSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AbstractOpenApiSchema.java index 4e975f5cf1..0ef554ef48 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AbstractOpenApiSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AbstractOpenApiSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateSubstate.java index 6d43fc77d7..99250bd37b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateSubstateAllOf.java index 6d4516418a..470fc47ce7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateValue.java index b0b0230803..a29ea1878f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessControllerFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRule.java index 78ad1e6f63..cb8b851f1e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleNode.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleNode.java index ad8f15b0c0..521c43f7ba 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleNode.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleNode.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleNodeType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleNodeType.java index 98f8295c60..3772bd9033 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleNodeType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleNodeType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleType.java index 6fe8e25b03..584f1eec12 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccessRuleType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntrySubstate.java index 2f2b4fc728..cee598c572 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntrySubstateAllOf.java index ce15829612..b66d191435 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntryValue.java index 817f9f3da4..ebdacc3433 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountAuthorizedDepositorEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateSubstate.java index e06ae1d7d9..44a436ee82 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateSubstateAllOf.java index 6cddfa4d93..805621915f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateValue.java index aad1761688..67a0b316db 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntrySubstate.java index a30c68a541..f1cf14800e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntrySubstateAllOf.java index 1e3c7aa74c..cde1c05d84 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntryValue.java index a44b46bd52..e37314aa28 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountResourcePreferenceEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntrySubstate.java index 6f49a067b3..5f64ef645d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntrySubstateAllOf.java index feae6eec5f..195728016a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntryValue.java index c1f3ab547e..4918d8d73d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AccountVaultEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidator.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidator.java index 058ab2d55c..e22736a6cd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidator.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidator.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidatorIndex.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidatorIndex.java index 9ebbea568e..4626286d46 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidatorIndex.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidatorIndex.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidatorKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidatorKey.java index e512363d5a..22863f1c90 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidatorKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ActiveValidatorKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AddressType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AddressType.java index 91f7de6952..8f235012ef 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AddressType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AddressType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfAccessRuleNode.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfAccessRuleNode.java index f9d0c6a3a6..707d415d2f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfAccessRuleNode.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfAccessRuleNode.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfProofRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfProofRule.java index 10f5eb3bb0..9a82c11741 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfProofRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfProofRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfProofRuleAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfProofRuleAllOf.java index 38d11b08a6..cb53538956 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfProofRuleAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllOfProofRuleAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllowAllAccessRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllowAllAccessRule.java index b19efea709..3dac726c92 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllowAllAccessRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AllowAllAccessRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AmountOfProofRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AmountOfProofRule.java index 3fd1e5e3d5..06ad762283 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AmountOfProofRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AmountOfProofRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AmountOfProofRuleAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AmountOfProofRuleAllOf.java index aa96f45532..f58d6d1a9a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AmountOfProofRuleAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AmountOfProofRuleAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfAccessRuleNode.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfAccessRuleNode.java index 165abba09e..cbc195ad23 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfAccessRuleNode.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfAccessRuleNode.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfAccessRuleNodeAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfAccessRuleNodeAllOf.java index 4d80eddcd9..cba3220566 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfAccessRuleNodeAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfAccessRuleNodeAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfProofRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfProofRule.java index 8b40c44331..5a4ce8f57f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfProofRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AnyOfProofRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AttachedModuleId.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AttachedModuleId.java index 14eab38304..568033e7d5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AttachedModuleId.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AttachedModuleId.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthConfig.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthConfig.java index bf636689fe..56f2ad972c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthConfig.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthConfig.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorBadge.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorBadge.java index 3dce0dd54b..eb48abf0a3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorBadge.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorBadge.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorBadgeType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorBadgeType.java index 90743e5fed..82db201505 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorBadgeType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorBadgeType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorKey.java index 6b6301124e..0040ce61e2 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/AuthorizedDepositorKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BasicErrorResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BasicErrorResponse.java index d2302887be..38073b2869 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BasicErrorResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BasicErrorResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BinaryPlaintextMessageContent.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BinaryPlaintextMessageContent.java index 6f51b73c38..ffae331b06 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BinaryPlaintextMessageContent.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BinaryPlaintextMessageContent.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BinaryPlaintextMessageContentAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BinaryPlaintextMessageContentAllOf.java index b55659dc18..7b38f159a1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BinaryPlaintextMessageContentAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BinaryPlaintextMessageContentAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintCollectionSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintCollectionSchema.java index c47dcb1b84..ceaef17895 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintCollectionSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintCollectionSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintCollectionSchemaType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintCollectionSchemaType.java index 275a2e2ef8..ebf894f190 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintCollectionSchemaType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintCollectionSchemaType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintDefinition.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintDefinition.java index c24811cdca..7f28567b2e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintDefinition.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintDefinition.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintDependencies.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintDependencies.java index f992dd50bd..7f0a484035 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintDependencies.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintDependencies.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintFunctionTargetIdentifier.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintFunctionTargetIdentifier.java index b25bad31dd..beb9931ec1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintFunctionTargetIdentifier.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintFunctionTargetIdentifier.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintFunctionTargetIdentifierAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintFunctionTargetIdentifierAllOf.java index 3b2d2a5923..3cdb369f02 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintFunctionTargetIdentifierAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintFunctionTargetIdentifierAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintInfo.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintInfo.java index ecde0583a1..d60572ed18 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintInfo.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintInfo.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintInterface.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintInterface.java index 9bc60d2057..6e296a2abf 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintInterface.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintInterface.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintMethodRoyalty.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintMethodRoyalty.java index b21b975f76..0d1db0e6c1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintMethodRoyalty.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintMethodRoyalty.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintPayloadDef.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintPayloadDef.java index e6d137358b..6cc8627b7e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintPayloadDef.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintPayloadDef.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintPayloadDefType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintPayloadDefType.java index 9b89b0f118..75b517cbc3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintPayloadDefType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintPayloadDefType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintRoyaltyConfig.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintRoyaltyConfig.java index e75dff1e64..960c80a94a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintRoyaltyConfig.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintRoyaltyConfig.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaBlueprintTypeReference.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaBlueprintTypeReference.java index cf609a217c..1bbb2e9bc2 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaBlueprintTypeReference.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaBlueprintTypeReference.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaBlueprintTypeReferenceAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaBlueprintTypeReferenceAllOf.java index dfc9959a2d..b08b36ca59 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaBlueprintTypeReferenceAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaBlueprintTypeReferenceAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaCollectionPartition.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaCollectionPartition.java index ab1c7b2af7..184241c518 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaCollectionPartition.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaCollectionPartition.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaFieldPartition.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaFieldPartition.java index cb736e0379..595211244a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaFieldPartition.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintSchemaFieldPartition.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeIdentifier.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeIdentifier.java index 98d59b85f6..d7d9a5157e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeIdentifier.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeIdentifier.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeReference.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeReference.java index 832eb5c37d..4fef46a057 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeReference.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeReference.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeReferenceKind.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeReferenceKind.java index d56bbf28c3..1f0466b195 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeReferenceKind.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintTypeReferenceKind.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintVersionKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintVersionKey.java index f3569a2da7..c5743fadf8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintVersionKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BlueprintVersionKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootSubstate.java index ddbad6fb17..309683c386 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootSubstateAllOf.java index 572c6897f5..d8235826d9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootValue.java index cf7167926c..72d366dd02 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/BootLoaderModuleFieldVmBootValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedIntentMetadata.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedIntentMetadata.java index fa3b193d0f..9c8a96294c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedIntentMetadata.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedIntentMetadata.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedStateIdentifier.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedStateIdentifier.java index b553e69852..40bb8e6c8b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedStateIdentifier.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedStateIdentifier.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedStateIdentifierAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedStateIdentifierAllOf.java index 2d71ac5d6d..7473854959 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedStateIdentifierAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedStateIdentifierAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedTransaction.java index 782fcd724d..0230beff68 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedTransactionBalanceChanges.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedTransactionBalanceChanges.java index 4d189d4a17..521a94b1b7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedTransactionBalanceChanges.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CommittedTransactionBalanceChanges.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ComponentMethodTargetIdentifier.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ComponentMethodTargetIdentifier.java index 305e656647..4f30ee2dd5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ComponentMethodTargetIdentifier.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ComponentMethodTargetIdentifier.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ComponentMethodTargetIdentifierAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ComponentMethodTargetIdentifierAllOf.java index 271558359c..50878d6003 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ComponentMethodTargetIdentifierAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ComponentMethodTargetIdentifierAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusLedgerProofOrigin.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusLedgerProofOrigin.java index 8e4c153f2f..c7df326dca 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusLedgerProofOrigin.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusLedgerProofOrigin.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusLedgerProofOriginAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusLedgerProofOriginAllOf.java index 667c24c9bd..04b756d90d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusLedgerProofOriginAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusLedgerProofOriginAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigSubstate.java index 962be84529..22495680de 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigSubstateAllOf.java index 7591992c00..6a652e25bb 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigValue.java index 2da6ac50d7..84082870b0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldConfigValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstate.java index 4957b5d39e..3b8845b279 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstateAllOf.java index a2cbd7d3fd..143e5b8e36 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticValue.java index cdbffa5481..92bcd207e3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentProposalStatisticValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstate.java index 32454abb09..8ab49cc5bc 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstateAllOf.java index 2d97736e7a..9b7bd50b3f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesValue.java index 768ca09cea..38148e540b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeSubstate.java index 5a0998232a..d6f66eb70c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeSubstateAllOf.java index 238d9aee6a..202887cdc2 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeValue.java index d771da5b7e..5808f36acb 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentTimeValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstate.java index 11042f5b3c..67dba4443c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstateAllOf.java index 955b4b925f..08ce446df8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetValue.java index e7b4f037f9..d4a58b0035 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldCurrentValidatorSetValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateSubstate.java index bf923629d7..36a13c7281 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateSubstateAllOf.java index 729aa05218..ff062b41f1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateValue.java index 640970539d..fa6e1be166 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsSubstate.java index d9b0d386a7..37d6a16483 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsSubstateAllOf.java index 84e7e68b6d..c6e2f84bff 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsValue.java index 76e56d0771..1eb7a5ab0b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerFieldValidatorRewardsValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstate.java index 18fff11d27..e927010a6d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstateAllOf.java index 875ed884f4..4625031d22 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntryValue.java index b8b9db6180..640f0f705a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CostingParameters.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CostingParameters.java index 530311579b..42769e4f8f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CostingParameters.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CostingParameters.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CountOfProofRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CountOfProofRule.java index a8df131222..b52abba13e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CountOfProofRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CountOfProofRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CountOfProofRuleAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CountOfProofRuleAllOf.java index 892f092775..7238df8f52 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CountOfProofRuleAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CountOfProofRuleAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CreatedSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CreatedSubstate.java index d8bc26d55c..d9c1c6497f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/CreatedSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/CreatedSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/DataStruct.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/DataStruct.java index c2e7023281..d3740b67eb 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/DataStruct.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/DataStruct.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/DefaultDepositRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/DefaultDepositRule.java index 3d1e2fb4a6..ac6c78164a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/DefaultDepositRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/DefaultDepositRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/DeletedSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/DeletedSubstate.java index ee0711f6c2..14002ca701 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/DeletedSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/DeletedSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/DenyAllAccessRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/DenyAllAccessRule.java index 7a3efaf053..7ab04fd4b0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/DenyAllAccessRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/DenyAllAccessRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1PublicKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1PublicKey.java index b076da6ab5..b6b94c0206 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1PublicKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1PublicKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1PublicKeyAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1PublicKeyAllOf.java index 473cf1e3a0..7e5c4efdf9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1PublicKeyAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1PublicKeyAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1Signature.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1Signature.java index 8c83f3e5ad..a3f3232111 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1Signature.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1Signature.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureAllOf.java index 80de38d135..f6932f6875 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureWithPublicKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureWithPublicKey.java index a8e65f279b..af9f8fa188 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureWithPublicKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureWithPublicKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureWithPublicKeyAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureWithPublicKeyAllOf.java index 30d3f2153a..1064d85a83 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureWithPublicKeyAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EcdsaSecp256k1SignatureWithPublicKeyAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519PublicKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519PublicKey.java index 341e3707d2..eafcf679a1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519PublicKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519PublicKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519PublicKeyAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519PublicKeyAllOf.java index 1a7ab8c9f5..2b765e5ebd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519PublicKeyAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519PublicKeyAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519Signature.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519Signature.java index ac43284cd4..1349443179 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519Signature.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519Signature.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureAllOf.java index ce5795b7de..29d11698c2 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureWithPublicKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureWithPublicKey.java index 894525be8e..104a2adb27 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureWithPublicKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureWithPublicKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureWithPublicKeyAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureWithPublicKeyAllOf.java index 3ab812892b..dc76c1a65d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureWithPublicKeyAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EddsaEd25519SignatureWithPublicKeyAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedMessageCurveDecryptorSet.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedMessageCurveDecryptorSet.java index 00e3eafeee..d16c2b95de 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedMessageCurveDecryptorSet.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedMessageCurveDecryptorSet.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedMessageDecryptor.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedMessageDecryptor.java index 00404ebcb1..bf313c7724 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedMessageDecryptor.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedMessageDecryptor.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedTransactionMessage.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedTransactionMessage.java index 9a53b5d78e..c9ddd0033c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedTransactionMessage.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedTransactionMessage.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedTransactionMessageAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedTransactionMessageAllOf.java index 1f2d50051e..1b6f028925 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedTransactionMessageAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EncryptedTransactionMessageAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityModule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityModule.java index 4584b44099..717d37552a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityModule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityModule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityReference.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityReference.java index e069f0bbba..2a874ba691 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityReference.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityReference.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityType.java index aa927bcea3..b9cb1b148b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EntityType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochChangeCondition.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochChangeCondition.java index 458d9c76f1..c8a65a5554 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochChangeCondition.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochChangeCondition.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochEndLedgerProof.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochEndLedgerProof.java index bf7b415307..d75cb44e69 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochEndLedgerProof.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochEndLedgerProof.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochRound.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochRound.java index cf322d76db..154c62e1ed 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochRound.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EpochRound.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ErrorResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ErrorResponse.java index e90906c0f4..9948eb9b48 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ErrorResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ErrorResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ErrorResponseType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ErrorResponseType.java index 17dfda1042..305109a6ec 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ErrorResponseType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ErrorResponseType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Event.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Event.java index 62f9a17ffd..4d97120127 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Event.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Event.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventEmitterIdentifier.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventEmitterIdentifier.java index 746ee75f6c..38da925ec7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventEmitterIdentifier.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventEmitterIdentifier.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventEmitterIdentifierType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventEmitterIdentifierType.java index 8c71c6905d..e4c6acd711 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventEmitterIdentifierType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventEmitterIdentifierType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventTypeIdentifier.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventTypeIdentifier.java index be236c042e..03daa4e700 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventTypeIdentifier.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/EventTypeIdentifier.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ExecutedGenesisScenario.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ExecutedGenesisScenario.java index 637d1f01dc..afd2bfc690 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ExecutedGenesisScenario.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ExecutedGenesisScenario.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ExecutedScenarioTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ExecutedScenarioTransaction.java index 55cd0fd701..0850e1ea55 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ExecutedScenarioTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ExecutedScenarioTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeDestination.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeDestination.java index 6e7209ae15..76d9616768 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeDestination.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeDestination.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeSource.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeSource.java index f791b0d8ba..663f1622cd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeSource.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeSource.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeSummary.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeSummary.java index 946513ae0a..7c7292ff43 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeSummary.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FeeSummary.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchema.java index ccbd425b4a..0c3f20c537 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureCondition.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureCondition.java index 9b2131bfdd..2d39920499 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureCondition.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureCondition.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionAlways.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionAlways.java index a309867373..aba2f2fd5c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionAlways.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionAlways.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeature.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeature.java index bff6f606ec..537a4ba7cd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeature.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeature.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOwnFeature.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOwnFeature.java index 4fddc24610..6600fc98fb 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOwnFeature.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOwnFeature.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOwnFeatureAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOwnFeatureAllOf.java index c93c8b1e47..66ac4860aa 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOwnFeatureAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionIfOwnFeatureAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionType.java index a48cf39cc5..87d2ffec60 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSchemaFeatureConditionType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSubstateKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSubstateKey.java index 33d18ef9ee..c41fd0bb19 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSubstateKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSubstateKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSubstateKeyAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSubstateKeyAllOf.java index 790889f6ff..8cdb8c2c34 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSubstateKeyAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FieldSubstateKeyAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashLedgerTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashLedgerTransaction.java index bdea8dfb18..23983144bd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashLedgerTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashLedgerTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashLedgerTransactionAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashLedgerTransactionAllOf.java index b7aa450b58..56300605ac 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashLedgerTransactionAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashLedgerTransactionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashSetSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashSetSubstate.java index ab6718a125..9a015d4a93 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashSetSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashSetSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashedStateUpdates.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashedStateUpdates.java index 680916eba7..3fde2d4215 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashedStateUpdates.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FlashedStateUpdates.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FrozenStatus.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FrozenStatus.java index 81e7da0cf1..d69f43aa37 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FrozenStatus.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FrozenStatus.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FullyScopedTypeId.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FullyScopedTypeId.java index e6f5eac19e..340bbcab55 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FullyScopedTypeId.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FullyScopedTypeId.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionAuthType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionAuthType.java index a059b32b91..0ddc225fdd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionAuthType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionAuthType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionEventEmitterIdentifier.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionEventEmitterIdentifier.java index c568a0db78..6c5cd91203 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionEventEmitterIdentifier.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionEventEmitterIdentifier.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionEventEmitterIdentifierAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionEventEmitterIdentifierAllOf.java index f530ff6842..9eb1656493 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionEventEmitterIdentifierAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionEventEmitterIdentifierAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionSchema.java index 99a21b0252..a789fa373c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FunctionSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceAmount.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceAmount.java index 53a9b2b594..ca828cf722 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceAmount.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceAmount.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceAmountAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceAmountAllOf.java index 74874f90f4..0a73300884 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceAmountAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceAmountAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilitySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilitySubstate.java index f088c191c3..9b624bd71b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilitySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilitySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilitySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilitySubstateAllOf.java index 14da8ab18d..f4942ff1bd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilitySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilitySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilityValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilityValue.java index 6bddf73c58..0fc0706891 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilityValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldDivisibilityValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplySubstate.java index 53d5e63760..19523b2270 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplySubstateAllOf.java index 72ad395af8..7fd31fc54d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplyValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplyValue.java index 098dc19f14..449e10d294 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplyValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleResourceManagerFieldTotalSupplyValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceSubstate.java index e6be8912d6..d1ca4325db 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceSubstateAllOf.java index 255f5e43a3..dffa1bf1dd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceValue.java index beea7564ae..edebff8b4e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldBalanceValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusSubstate.java index 140f17b3a3..1e2ab10a06 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusSubstateAllOf.java index 160b13e673..2bf3a96b26 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusValue.java index c43370021c..b966af8ed6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/FungibleVaultFieldFrozenStatusValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericBlueprintPayloadDef.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericBlueprintPayloadDef.java index 09ca708304..e4501ff0a9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericBlueprintPayloadDef.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericBlueprintPayloadDef.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericBlueprintPayloadDefAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericBlueprintPayloadDefAllOf.java index 6e269ec9a7..2c441f3469 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericBlueprintPayloadDefAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericBlueprintPayloadDefAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKey.java index f985b7cfc4..35de098767 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntrySubstate.java index 138f120223..2fec50d53a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntrySubstateAllOf.java index c8422b44f7..d916486a24 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntryValue.java index 0f9991b35b..828195334d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericKeyValueStoreEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateSubstate.java index 83be824c83..3c5e9f16da 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateSubstateAllOf.java index aaf3ac244c..ad19c85e21 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateValue.java index 8e95080093..861139f3a9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericScryptoComponentFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericSubstitution.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericSubstitution.java index 5c85a39e02..4250006f58 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericSubstitution.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericSubstitution.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericSubstitutionType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericSubstitutionType.java index 3f55b5f45c..ccfc68528c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericSubstitutionType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericSubstitutionType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericTypeParameter.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericTypeParameter.java index 7f70b9b8e7..70c1e24b95 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericTypeParameter.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericTypeParameter.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericTypeParameterConstraints.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericTypeParameterConstraints.java index c90bc10542..b5659e127f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericTypeParameterConstraints.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenericTypeParameterConstraints.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerProofOrigin.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerProofOrigin.java index 1001156146..fb12195524 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerProofOrigin.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerProofOrigin.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerProofOriginAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerProofOriginAllOf.java index 1afe52e5c4..7f5b99e5d8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerProofOriginAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerProofOriginAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerTransaction.java index ad8b3234ab..91fb79e15a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerTransactionAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerTransactionAllOf.java index f34bf53df4..f76caae568 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerTransactionAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/GenesisLedgerTransactionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/HookExport.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/HookExport.java index 7d633150f9..c67283696b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/HookExport.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/HookExport.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexBlueprintCollectionSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexBlueprintCollectionSchema.java index 529eee1a7e..dcb1d8a9e6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexBlueprintCollectionSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexBlueprintCollectionSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexBlueprintCollectionSchemaAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexBlueprintCollectionSchemaAllOf.java index 5835d6cd29..d521d1bfa9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexBlueprintCollectionSchemaAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexBlueprintCollectionSchemaAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexedStateSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexedStateSchema.java index 07836afdfe..6915b48444 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexedStateSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/IndexedStateSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstanceSchemaBlueprintTypeReference.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstanceSchemaBlueprintTypeReference.java index dad23dfb4b..dda0fae553 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstanceSchemaBlueprintTypeReference.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstanceSchemaBlueprintTypeReference.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstanceSchemaBlueprintTypeReferenceAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstanceSchemaBlueprintTypeReferenceAllOf.java index f6c1961f95..5bc3a38d9c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstanceSchemaBlueprintTypeReferenceAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstanceSchemaBlueprintTypeReferenceAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Instant.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Instant.java index 1bc9a29762..5e9c58f5b4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Instant.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Instant.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstructionResourceChanges.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstructionResourceChanges.java index e357a71952..95decf22b0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstructionResourceChanges.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/InstructionResourceChanges.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBasedStructure.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBasedStructure.java index e77269e22f..604667bfc0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBasedStructure.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBasedStructure.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBlueprintCollectionSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBlueprintCollectionSchema.java index 91bec78c27..ba93ab3cd8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBlueprintCollectionSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBlueprintCollectionSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBlueprintCollectionSchemaAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBlueprintCollectionSchemaAllOf.java index 9fe2a043a9..f05284d082 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBlueprintCollectionSchemaAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueBlueprintCollectionSchemaAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreEntryStructure.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreEntryStructure.java index 479a60c255..df027844d3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreEntryStructure.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreEntryStructure.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreEntryStructureAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreEntryStructureAllOf.java index 84ca2731ee..14689edb8f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreEntryStructureAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreEntryStructureAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreInfo.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreInfo.java index b428d97ba8..135ab184cf 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreInfo.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreInfo.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreTypeInfoDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreTypeInfoDetails.java index f24f157c63..773d22c112 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreTypeInfoDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreTypeInfoDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreTypeInfoDetailsAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreTypeInfoDetailsAllOf.java index e35a1d1834..47377c06bc 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreTypeInfoDetailsAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/KeyValueStoreTypeInfoDetailsAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LeaderProposalHistory.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LeaderProposalHistory.java index da60c102a8..25e462e0d3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LeaderProposalHistory.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LeaderProposalHistory.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHashes.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHashes.java index 14fd9d7d29..629c96aaf5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHashes.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHashes.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHeader.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHeader.java index ccd2c8d08e..92c78dc07f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHeader.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHeader.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHeaderSummary.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHeaderSummary.java index 081eb6ba6f..2c42dfd229 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHeaderSummary.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerHeaderSummary.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProof.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProof.java index 35d012bc94..f72f910b39 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProof.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProof.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProofOrigin.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProofOrigin.java index d90d11d93a..ebb7e26719 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProofOrigin.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProofOrigin.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProofOriginType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProofOriginType.java index 482513a950..623581d2c8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProofOriginType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerProofOriginType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerStateSummary.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerStateSummary.java index 59eb6383e5..f0763309c1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerStateSummary.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerStateSummary.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerTransaction.java index 4faefa4ae9..d1f59d0802 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerTransactionType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerTransactionType.java index e3d88a0caa..05cf7c1c78 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerTransactionType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LedgerTransactionType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalGenericSubstitution.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalGenericSubstitution.java index 3133a49830..d9dda447e5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalGenericSubstitution.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalGenericSubstitution.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalGenericSubstitutionAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalGenericSubstitutionAllOf.java index 7f6b33caf0..0c48a6ebf5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalGenericSubstitutionAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalGenericSubstitutionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalNonFungibleKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalNonFungibleKey.java index 1aaac4a6c1..3425aaf99c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalNonFungibleKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalNonFungibleKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalTypeId.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalTypeId.java index 0a53e419e0..c0a278dc48 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalTypeId.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LocalTypeId.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsCommittedTransactionOutcome.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsCommittedTransactionOutcome.java index 9a3c93f8b7..37cd952b2c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsCommittedTransactionOutcome.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsCommittedTransactionOutcome.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsCommittedTransactionStatus.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsCommittedTransactionStatus.java index efe5f92a7a..2848388d5d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsCommittedTransactionStatus.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsCommittedTransactionStatus.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsEntityFungibleBalanceChanges.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsEntityFungibleBalanceChanges.java index f6d0568334..a4ab5aed76 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsEntityFungibleBalanceChanges.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsEntityFungibleBalanceChanges.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsEntityNonFungibleBalanceChanges.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsEntityNonFungibleBalanceChanges.java index fd8833671f..318fd56ecd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsEntityNonFungibleBalanceChanges.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsEntityNonFungibleBalanceChanges.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFeeFungibleResourceBalanceChange.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFeeFungibleResourceBalanceChange.java index 4eb4f303be..ad50765bae 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFeeFungibleResourceBalanceChange.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFeeFungibleResourceBalanceChange.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFeeFungibleResourceBalanceChangeType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFeeFungibleResourceBalanceChangeType.java index e2c6f5d338..e8560004be 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFeeFungibleResourceBalanceChangeType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFeeFungibleResourceBalanceChangeType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFungibleResourceBalance.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFungibleResourceBalance.java index d56e65df41..ec7a3d01b6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFungibleResourceBalance.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFungibleResourceBalance.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFungibleResourceBalanceChange.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFungibleResourceBalanceChange.java index eb4adcd870..31f6f472b1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFungibleResourceBalanceChange.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsFungibleResourceBalanceChange.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsResultantAccountFungibleBalances.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsResultantAccountFungibleBalances.java index fc24653c6d..879f983ae5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsResultantAccountFungibleBalances.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsResultantAccountFungibleBalances.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsResultantFungibleBalance.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsResultantFungibleBalance.java index 8193d478ba..58e432fe4b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsResultantFungibleBalance.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsResultantFungibleBalance.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountAllFungibleResourceBalancesRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountAllFungibleResourceBalancesRequest.java index 052566625a..c9cdae410f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountAllFungibleResourceBalancesRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountAllFungibleResourceBalancesRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountAllFungibleResourceBalancesResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountAllFungibleResourceBalancesResponse.java index de23f78a40..f706da4c95 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountAllFungibleResourceBalancesResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountAllFungibleResourceBalancesResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountDepositBehaviourRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountDepositBehaviourRequest.java index 3ecaabdb26..3390b211a1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountDepositBehaviourRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountDepositBehaviourRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountDepositBehaviourResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountDepositBehaviourResponse.java index 076fe6abe6..fb7cf794ee 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountDepositBehaviourResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountDepositBehaviourResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountFungibleResourceBalanceRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountFungibleResourceBalanceRequest.java index 1ad0a7e693..dca8858d2d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountFungibleResourceBalanceRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountFungibleResourceBalanceRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountFungibleResourceBalanceResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountFungibleResourceBalanceResponse.java index a8f8c99484..30505e8030 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountFungibleResourceBalanceResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStateAccountFungibleResourceBalanceResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamAccountTransactionOutcomesRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamAccountTransactionOutcomesRequest.java index 19949cfcdd..f78d1377ca 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamAccountTransactionOutcomesRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamAccountTransactionOutcomesRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamAccountTransactionOutcomesResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamAccountTransactionOutcomesResponse.java index 5f4eab0bea..abf171ecb7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamAccountTransactionOutcomesResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamAccountTransactionOutcomesResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamTransactionOutcomesRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamTransactionOutcomesRequest.java index 1c06609b9f..bee4415eb7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamTransactionOutcomesRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamTransactionOutcomesRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamTransactionOutcomesResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamTransactionOutcomesResponse.java index 57109dacce..7e3edea3b9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamTransactionOutcomesResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsStreamTransactionOutcomesResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionConstructionRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionConstructionRequest.java index 4fcc1b8693..8bdc022932 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionConstructionRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionConstructionRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionConstructionResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionConstructionResponse.java index 9b5df3f40e..08b277b9c1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionConstructionResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionConstructionResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionIntentStatus.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionIntentStatus.java index ed2730e6db..fab2f00260 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionIntentStatus.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionIntentStatus.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionPayloadDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionPayloadDetails.java index 4c9d64a7b0..f2c8bd5763 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionPayloadDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionPayloadDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionPayloadStatus.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionPayloadStatus.java index 88d4091ea7..971079cb5a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionPayloadStatus.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionPayloadStatus.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionStatusRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionStatusRequest.java index 9df691f243..148bd0777b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionStatusRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionStatusRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionStatusResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionStatusResponse.java index 0b5df62185..464e3db09c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionStatusResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionStatusResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorDetails.java index f8a7403537..282a52751a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorDetailsType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorDetailsType.java index 7a3c7cf3a8..0a4507307c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorDetailsType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorDetailsType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorResponse.java index b1baa6e749..c0519ad834 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorResponseAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorResponseAllOf.java index b169b717f7..1c3138401a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorResponseAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitErrorResponseAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitIntentAlreadyCommitted.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitIntentAlreadyCommitted.java index a497271b1a..2ab53afcca 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitIntentAlreadyCommitted.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitIntentAlreadyCommitted.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitIntentAlreadyCommittedAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitIntentAlreadyCommittedAllOf.java index 8379bb6ffb..b246256ecd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitIntentAlreadyCommittedAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitIntentAlreadyCommittedAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetails.java index 14ce55afa2..ac74f271d3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetailsAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetailsAllOf.java index f16c0c6151..cb49191c9e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetailsAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetailsAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRejectedErrorDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRejectedErrorDetails.java index c8bb9f8b76..d43c732e3f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRejectedErrorDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRejectedErrorDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRejectedErrorDetailsAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRejectedErrorDetailsAllOf.java index 0854278397..def980d4d4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRejectedErrorDetailsAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRejectedErrorDetailsAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRequest.java index c5767c0127..01d2673bc8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitResponse.java index a952cde5c5..18a29ad422 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/LtsTransactionSubmitResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MainMethodKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MainMethodKey.java index 901b351d14..8432b2d612 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MainMethodKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MainMethodKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MapSubstateKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MapSubstateKey.java index 5bdd3be11d..ec678d67b6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MapSubstateKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MapSubstateKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MapSubstateKeyAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MapSubstateKeyAllOf.java index 2d2c3a5bb9..c6c4a78d48 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MapSubstateKeyAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MapSubstateKeyAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolListRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolListRequest.java index d6d8fd3f3f..9014dcd13e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolListRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolListRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolListResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolListResponse.java index a132da94c9..62d0bf7a43 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolListResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolListResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionHashes.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionHashes.java index 71c5ca8da1..3be9707fba 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionHashes.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionHashes.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionRequest.java index 0158de6491..69d226c8c5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionResponse.java index b3752a8ba5..ccdb23b61b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionResponsePayloadsInner.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionResponsePayloadsInner.java index bc111b0334..879bb69ddf 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionResponsePayloadsInner.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MempoolTransactionResponsePayloadsInner.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataKey.java index 228c3b8266..79d1a112e9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntrySubstate.java index 00221de7b9..4466747cd8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntrySubstateAllOf.java index 5267a8fb2f..068be82ddd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntryValue.java index 369919ed52..02669ce614 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MetadataModuleEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAccessibility.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAccessibility.java index b02e1bdaea..cce256284e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAccessibility.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAccessibility.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAccessibilityType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAccessibilityType.java index 493d37e99d..cc6abc755d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAccessibilityType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAccessibilityType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAuthType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAuthType.java index 98758aa3a0..c9ebcc3c02 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAuthType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodAuthType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodEventEmitterIdentifier.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodEventEmitterIdentifier.java index 4472345ed6..f6f4faa1c0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodEventEmitterIdentifier.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodEventEmitterIdentifier.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodEventEmitterIdentifierAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodEventEmitterIdentifierAllOf.java index d4178a4e39..38ea85f55f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodEventEmitterIdentifierAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MethodEventEmitterIdentifierAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ModuleId.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ModuleId.java index 65c51b7e43..b89f9626d1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ModuleId.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ModuleId.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ModuleVersion.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ModuleVersion.java index 77d1e5e9d6..1999129019 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ModuleVersion.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ModuleVersion.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateSubstate.java index 1055e7a84a..b88bf64dc6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateSubstateAllOf.java index 72ca9f9cac..dbce1e897c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateValue.java index f3c4027040..d4b23a0fc5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MultiResourcePoolFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MutableField.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MutableField.java index 12c906244d..88097f0aff 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/MutableField.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/MutableField.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponse.java index c80b252073..4cefa777d2 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponseVersion.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponseVersion.java index 1321cd9c02..efa11cd259 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponseVersion.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponseVersion.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponseWellKnownAddresses.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponseWellKnownAddresses.java index 235eae85ab..54c61e7c3a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponseWellKnownAddresses.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkConfigurationResponseWellKnownAddresses.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkStatusRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkStatusRequest.java index e0f3bceab9..5f57d24fe4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkStatusRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkStatusRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkStatusResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkStatusResponse.java index 31f5c7447f..53914d26f6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkStatusResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NetworkStatusResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NextEpoch.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NextEpoch.java index 3879735685..3acd113226 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NextEpoch.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NextEpoch.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleAuthorizedDepositorBadge.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleAuthorizedDepositorBadge.java index f860ece763..4797c0da31 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleAuthorizedDepositorBadge.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleAuthorizedDepositorBadge.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleAuthorizedDepositorBadgeAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleAuthorizedDepositorBadgeAllOf.java index 4f3422b0e2..99c86e5b33 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleAuthorizedDepositorBadgeAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleAuthorizedDepositorBadgeAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleGlobalId.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleGlobalId.java index ab0e120749..42d6c1e803 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleGlobalId.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleGlobalId.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleIdType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleIdType.java index 4a984d65b9..1d5dcecd3e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleIdType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleIdType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleLocalId.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleLocalId.java index 0155a6f85f..a967c993c0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleLocalId.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleLocalId.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungiblePresentedBadge.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungiblePresentedBadge.java index e18c68936a..573cae0c72 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungiblePresentedBadge.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungiblePresentedBadge.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungiblePresentedBadgeAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungiblePresentedBadgeAllOf.java index 94b152317d..b924fb9bc8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungiblePresentedBadgeAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungiblePresentedBadgeAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleRequirement.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleRequirement.java index e190aa870f..8ebc8bad2f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleRequirement.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleRequirement.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleRequirementAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleRequirementAllOf.java index a69c172579..0070ff6d24 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleRequirementAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleRequirementAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceAmount.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceAmount.java index bc99f89f84..0027b27828 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceAmount.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceAmount.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceAmountAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceAmountAllOf.java index b668cc84f2..cc1a7b27ac 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceAmountAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceAmountAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntrySubstate.java index 8260d10298..5d8ab13d13 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntrySubstateAllOf.java index 2a1b0bfc60..4099bfd853 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntryValue.java index bb362b6bc5..d45d9c8a5c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerDataEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeSubstate.java index 4324edf633..b935b5d2a7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeSubstateAllOf.java index 14b2d7c251..0a7c1b3f38 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeValue.java index d2e928ccf4..0f14710c3e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldIdTypeValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstate.java index 3e3250afae..0f5f52c53c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstateAllOf.java index ecc6eb56c9..9e463e3dcf 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsValue.java index 67e32c7a68..a4ad65c585 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldMutableFieldsValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstate.java index db3e06b434..5c46109070 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstateAllOf.java index 47a9e0ed7c..6bb00a1293 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplyValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplyValue.java index dc93e9f520..6b3b6c8ffe 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplyValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleResourceManagerFieldTotalSupplyValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntrySubstate.java index 420482bb8e..b017e652e7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntrySubstateAllOf.java index 91ccd395d9..e900e3ffba 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntryValue.java index 8d0ad2c259..8a27fd08b7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultContentsIndexEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceSubstate.java index 9dcab45b10..489595cd42 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceSubstateAllOf.java index 782390a9d1..e49774b59c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceValue.java index c464e9949c..9f1e640e89 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldBalanceValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusSubstate.java index 1b5dac9da6..5cd3ea74a1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusSubstateAllOf.java index 83e5739870..7c87dddc58 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusValue.java index b581a77d36..4d6ec577a9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NonFungibleVaultFieldFrozenStatusValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NotarizedTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NotarizedTransaction.java index 3f2c13049d..c84dfefc50 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/NotarizedTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/NotarizedTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectFieldStructure.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectFieldStructure.java index ed6e52d7ac..986c4789dc 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectFieldStructure.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectFieldStructure.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectFieldStructureAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectFieldStructureAllOf.java index dc58b9cbd4..b3528fcb6b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectFieldStructureAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectFieldStructureAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectHook.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectHook.java index be6ed86025..96ab1120ca 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectHook.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectHook.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectIndexPartitionEntryStructure.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectIndexPartitionEntryStructure.java index 1201449f7b..2de310dc8c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectIndexPartitionEntryStructure.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectIndexPartitionEntryStructure.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectInstanceTypeReference.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectInstanceTypeReference.java index 8b3dda597f..294c8977a9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectInstanceTypeReference.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectInstanceTypeReference.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectInstanceTypeReferenceAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectInstanceTypeReferenceAllOf.java index c558f7ef83..7f85d9b981 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectInstanceTypeReferenceAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectInstanceTypeReferenceAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectKeyValuePartitionEntryStructure.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectKeyValuePartitionEntryStructure.java index 5711f184be..8282d28111 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectKeyValuePartitionEntryStructure.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectKeyValuePartitionEntryStructure.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectRoleKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectRoleKey.java index 0b382e27c0..b6f1b41bd4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectRoleKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectRoleKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSortedIndexPartitionEntryStructure.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSortedIndexPartitionEntryStructure.java index e799510374..416188ced3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSortedIndexPartitionEntryStructure.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSortedIndexPartitionEntryStructure.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSubstateTypeReference.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSubstateTypeReference.java index ca467b4e9b..6021522cd0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSubstateTypeReference.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSubstateTypeReference.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSubstateTypeReferenceType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSubstateTypeReferenceType.java index 20e4ab9b9e..9991aa990b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSubstateTypeReferenceType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectSubstateTypeReferenceType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectTypeInfoDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectTypeInfoDetails.java index 1c89edb928..4685812839 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectTypeInfoDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectTypeInfoDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectTypeInfoDetailsAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectTypeInfoDetailsAllOf.java index e7e1af08ab..fac44f59aa 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectTypeInfoDetailsAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ObjectTypeInfoDetailsAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateSubstate.java index 2c4a87b731..095369f0f2 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateSubstateAllOf.java index b518e52549..b8a9126c13 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateValue.java index f7d20012e1..c7085e2b41 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OneResourcePoolFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OuterObjectOnlyMethodAccessibility.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OuterObjectOnlyMethodAccessibility.java index 8ff2469311..9ba716dec4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OuterObjectOnlyMethodAccessibility.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OuterObjectOnlyMethodAccessibility.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnPackageOnlyMethodAccessibility.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnPackageOnlyMethodAccessibility.java index 8b2c063720..c5766b3507 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnPackageOnlyMethodAccessibility.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnPackageOnlyMethodAccessibility.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnerRole.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnerRole.java index 88d4fb87b0..c92f4da9d7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnerRole.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnerRole.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnerRoleUpdater.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnerRoleUpdater.java index be071ebbe2..aacc6264a8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnerRoleUpdater.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/OwnerRoleUpdater.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntrySubstate.java index dd7a4e9da5..d1fcf309e3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntrySubstateAllOf.java index 3c3f9f524a..b0f418b8d3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntryValue.java index 3820de913c..3779a92552 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintAuthTemplateEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntrySubstate.java index e8a9551ace..71ec39ab88 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntrySubstateAllOf.java index a047444ca6..d9238d83ba 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntryValue.java index b93cd027fc..af956c12dc 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDefinitionEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntrySubstate.java index 4a24409649..ffce70aa72 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntrySubstateAllOf.java index bf66422ea2..4f6f0dea68 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntryValue.java index c9db552020..400e61409d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintDependenciesEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntrySubstate.java index 73ced70835..cbb17571f1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntrySubstateAllOf.java index 3768796c07..cbd33b28cb 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntryValue.java index 85422ffb15..cc70d4648c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageBlueprintRoyaltyEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntrySubstate.java index 302d4221d6..26d6c547b3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntrySubstateAllOf.java index a1b2da9bb3..ccbd4e4951 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntryValue.java index d22778207e..839db58c8c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeInstrumentedCodeEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeKey.java index 62a5250a59..e47787d41a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntrySubstate.java index e41da9749b..a7f02fd09a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntrySubstateAllOf.java index be31a9dd03..4fd8040e16 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntryValue.java index c4052260ce..07cd1859ad 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeOriginalCodeEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntrySubstate.java index 7d33d505fd..c375ec66b4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntrySubstateAllOf.java index 9da7107a5b..566b868521 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntryValue.java index 380766bef5..8e4455ca00 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageCodeVmTypeEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageExport.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageExport.java index b1c660d02c..d71b9b95a6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageExport.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageExport.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorSubstate.java index e05dd1e744..4c469db0ee 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorSubstateAllOf.java index 33beb045cd..9a35308abe 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorValue.java index 0615235901..08e8ec59ff 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageFieldRoyaltyAccumulatorValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageObjectSubstateTypeReference.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageObjectSubstateTypeReference.java index 4f4d6b0ece..2458ad7ee0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageObjectSubstateTypeReference.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageObjectSubstateTypeReference.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageTypeReference.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageTypeReference.java index d661e65457..5ab888a29e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageTypeReference.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PackageTypeReference.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransaction.java index 637f08099c..1bb5e2ebbe 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransactionAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransactionAllOf.java index dec4673e1b..d0002bc1aa 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransactionAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransactionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransactionIdentifiers.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransactionIdentifiers.java index 5a0e08e458..2d26740288 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransactionIdentifiers.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedLedgerTransactionIdentifiers.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransaction.java index 16177967d8..5ca9bfa208 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionAllOf.java index 535145fb39..a84df4bb3c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionAllOfValidationError.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionAllOfValidationError.java index 2e32ebdb19..72be88f6b0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionAllOfValidationError.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionAllOfValidationError.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionIdentifiers.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionIdentifiers.java index de257d1507..2fc26d5421 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionIdentifiers.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedNotarizedTransactionIdentifiers.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntent.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntent.java index 083415faae..30ae64fda8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntent.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntent.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntentAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntentAllOf.java index 4916fd13b3..8d517b67c8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntentAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntentAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntentIdentifiers.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntentIdentifiers.java index 8f6c6b2937..e38778d972 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntentIdentifiers.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedSignedTransactionIntentIdentifiers.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransaction.java index aab91613f0..7cce447cac 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntent.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntent.java index cf957006b4..76e6a1bff5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntent.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntent.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntentAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntentAllOf.java index 81317b67ba..49ab21d3e8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntentAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntentAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntentIdentifiers.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntentIdentifiers.java index 473d85631b..36fd5294ff 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntentIdentifiers.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionIntentIdentifiers.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionType.java index 92345f5078..5550693623 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ParsedTransactionType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionDescription.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionDescription.java index 1d3f4598eb..c0cefcd098 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionDescription.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionDescription.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionDescriptionType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionDescriptionType.java index 5f6d6f6a08..8dccd3286c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionDescriptionType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionDescriptionType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionId.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionId.java index 6edfe32606..0698d51ef0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionId.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionId.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionKind.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionKind.java index a72c4add9a..160f46cdd5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionKind.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PartitionKind.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PaymentFromVault.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PaymentFromVault.java index 7ab0c0ebc4..c892c8ad81 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PaymentFromVault.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PaymentFromVault.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PaymentToRoyaltyRecipient.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PaymentToRoyaltyRecipient.java index 77606095fc..45069c3a0c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PaymentToRoyaltyRecipient.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PaymentToRoyaltyRecipient.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PendingOwnerStakeWithdrawal.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PendingOwnerStakeWithdrawal.java index 1905c9b5c7..8cfcea09f6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PendingOwnerStakeWithdrawal.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PendingOwnerStakeWithdrawal.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextMessageContent.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextMessageContent.java index e18b20bb69..092785d844 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextMessageContent.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextMessageContent.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextMessageContentType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextMessageContentType.java index 7480d1878a..82a8b2fac2 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextMessageContentType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextMessageContentType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextTransactionMessage.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextTransactionMessage.java index 2c22541b1b..343bf9314c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextTransactionMessage.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextTransactionMessage.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextTransactionMessageAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextTransactionMessageAllOf.java index 7d721a653d..481ddc432b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextTransactionMessageAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PlaintextTransactionMessageAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PoolVault.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PoolVault.java index c53a95ecd2..226c4ed2a9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PoolVault.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PoolVault.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PresentedBadge.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PresentedBadge.java index baaa797042..d04831fe2f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PresentedBadge.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PresentedBadge.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PresentedBadgeType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PresentedBadgeType.java index 737c67f951..4b2727429f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PresentedBadgeType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PresentedBadgeType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PrimaryRoleRecoveryAttempt.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PrimaryRoleRecoveryAttempt.java index 9c6d2ab30d..ccb7f5e956 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PrimaryRoleRecoveryAttempt.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PrimaryRoleRecoveryAttempt.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofAccessRuleNode.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofAccessRuleNode.java index b868dc1807..16eb1de873 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofAccessRuleNode.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofAccessRuleNode.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofAccessRuleNodeAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofAccessRuleNodeAllOf.java index 67b38b4f98..5d9e5f7802 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofAccessRuleNodeAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofAccessRuleNodeAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofRule.java index 7560d4a3fa..d3ccd19575 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofRuleType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofRuleType.java index cdcc4e9910..ed148ea7b4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofRuleType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProofRuleType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProposerReward.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProposerReward.java index 574fe1e891..72371fcfaa 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProposerReward.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProposerReward.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtectedAccessRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtectedAccessRule.java index eb9ce81787..736d3a2706 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtectedAccessRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtectedAccessRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtectedAccessRuleAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtectedAccessRuleAllOf.java index 410f06b9a9..2f8dc52172 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtectedAccessRuleAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtectedAccessRuleAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolUpdateLedgerProofOrigin.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolUpdateLedgerProofOrigin.java index 559b01cada..2e1af4f43e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolUpdateLedgerProofOrigin.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolUpdateLedgerProofOrigin.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolUpdateLedgerProofOriginAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolUpdateLedgerProofOriginAllOf.java index ebf1ece0d7..eb1b2f87d6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolUpdateLedgerProofOriginAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolUpdateLedgerProofOriginAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolVersionReadiness.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolVersionReadiness.java index 38d197bf6b..9b3e484160 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolVersionReadiness.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ProtocolVersionReadiness.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicKey.java index 1518b10fce..7e8fc2cafd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicKeyType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicKeyType.java index c08f8378c8..ab431359b9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicKeyType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicKeyType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicMethodAccessibility.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicMethodAccessibility.java index c52ebd40d2..f61283faf3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicMethodAccessibility.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/PublicMethodAccessibility.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ReceiverInfo.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ReceiverInfo.java index fc0e419bdc..48fd514f69 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ReceiverInfo.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ReceiverInfo.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RecoveryProposal.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RecoveryProposal.java index 7a53d6a478..af7d954409 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RecoveryProposal.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RecoveryProposal.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RecoveryRoleRecoveryAttempt.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RecoveryRoleRecoveryAttempt.java index 8139b9046e..016822c727 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RecoveryRoleRecoveryAttempt.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RecoveryRoleRecoveryAttempt.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ReferenceType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ReferenceType.java index 469c4da06d..f1e14489b3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ReferenceType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ReferenceType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RemoteGenericSubstitution.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RemoteGenericSubstitution.java index d84fd8b72e..f8cd4a842d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RemoteGenericSubstitution.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RemoteGenericSubstitution.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RemoteGenericSubstitutionAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RemoteGenericSubstitutionAllOf.java index f7561d973d..3c127920ee 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RemoteGenericSubstitutionAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RemoteGenericSubstitutionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequestedStateVersionOutOfBoundsErrorDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequestedStateVersionOutOfBoundsErrorDetails.java index cd8f4db7b1..6afb3efc94 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequestedStateVersionOutOfBoundsErrorDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequestedStateVersionOutOfBoundsErrorDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequireProofRule.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequireProofRule.java index d8d3c46c7d..f7b64bfbe3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequireProofRule.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequireProofRule.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequireProofRuleAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequireProofRuleAllOf.java index 7971a1fc07..e7250f9dbc 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequireProofRuleAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequireProofRuleAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Requirement.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Requirement.java index 11e11fa524..f718fd74f1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Requirement.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Requirement.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequirementType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequirementType.java index 4377a7a8ff..4bcfb68090 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequirementType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RequirementType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAmount.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAmount.java index aa4c0bed10..fcb11dab0b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAmount.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAmount.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAuthorizedDepositorBadge.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAuthorizedDepositorBadge.java index d0deace157..2c6b46b3cd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAuthorizedDepositorBadge.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAuthorizedDepositorBadge.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAuthorizedDepositorBadgeAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAuthorizedDepositorBadgeAllOf.java index 326313220f..8eb8dda36c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAuthorizedDepositorBadgeAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceAuthorizedDepositorBadgeAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceChange.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceChange.java index 670b17db58..9ab76a7446 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceChange.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceChange.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceKey.java index 81c5c55647..159f45e18c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourcePreference.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourcePreference.java index 351903decb..5a48cfeee5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourcePreference.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourcePreference.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourcePresentedBadge.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourcePresentedBadge.java index d9c1d44898..818eb9aa49 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourcePresentedBadge.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourcePresentedBadge.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceRequirement.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceRequirement.java index d466d4d996..178e39bb99 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceRequirement.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceRequirement.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceRequirementAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceRequirementAllOf.java index 50fc13dc26..c74f6f9b5c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceRequirementAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceRequirementAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceSpecificDepositBehaviour.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceSpecificDepositBehaviour.java index 2468ff5d9c..2bc33d62c4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceSpecificDepositBehaviour.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceSpecificDepositBehaviour.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceType.java index 5567a9d4d0..db82b7567a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ResourceType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstate.java index 3a04bfd3b1..8dc3588bf5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstateAllOf.java index 6296d0e4fd..579a7e9917 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleValue.java index dd831346bb..076d59e865 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleFieldOwnerRoleValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntrySubstate.java index e6dd1ab775..b2cff64a61 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntrySubstateAllOf.java index e9a1bbf517..a75b50d1a4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntryValue.java index fabffd0b9b..96bf3d7209 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleAssignmentModuleRuleEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleDetails.java index 16a5a447a2..a0fd510f66 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleProtectedMethodAccessibility.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleProtectedMethodAccessibility.java index 8ae2bdcc44..9d89f03d34 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleProtectedMethodAccessibility.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleProtectedMethodAccessibility.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleProtectedMethodAccessibilityAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleProtectedMethodAccessibilityAllOf.java index 5174b7c3b0..8556f47a9d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleProtectedMethodAccessibilityAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleProtectedMethodAccessibilityAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleSpecification.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleSpecification.java index dedd956f94..91dfb5ae8e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleSpecification.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoleSpecification.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateLedgerTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateLedgerTransaction.java index 162ce96fef..dc5db09b41 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateLedgerTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateLedgerTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateLedgerTransactionAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateLedgerTransactionAllOf.java index 151c1a379b..1e565b3bda 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateLedgerTransactionAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateLedgerTransactionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateTransaction.java index 75f1de857b..bf1619adf9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoundUpdateTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyAmount.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyAmount.java index 9d8eabc66d..777ecebe69 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyAmount.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyAmount.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateSubstate.java index 198869af26..bd4fc98365 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateSubstateAllOf.java index bd77c55e07..319a614648 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateValue.java index 7e38b6ef61..ef68d846a9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstate.java index 6aee585e81..af92f26adb 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstateAllOf.java index 1d0e28e3db..07972d10da 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntryValue.java index cc4e4a2a05..c59ebf9162 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/RoyaltyModuleMethodRoyaltyEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SborData.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SborData.java index 3ab230cc12..f0c015d0e8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SborData.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SborData.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SborFormatOptions.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SborFormatOptions.java index 4995dd511d..cfc443c38f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SborFormatOptions.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SborFormatOptions.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScenariosRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScenariosRequest.java index 56ef04d940..4e1fd46641 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScenariosRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScenariosRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScenariosResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScenariosResponse.java index 600eb4272d..d40fd1d1a4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScenariosResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScenariosResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntrySubstate.java index af54225854..b8e8264205 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntrySubstateAllOf.java index 4b4a5a27c9..3b5e093af6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntryValue.java index 8a585289bf..b7e88c78a4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaKey.java index 35e20bd87d..05eb4ae3a4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SchemaKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScopedTypeId.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScopedTypeId.java index 1d9575ec4e..8a64fd4a14 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScopedTypeId.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScopedTypeId.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScryptoSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScryptoSchema.java index 4e119874f0..f143f21ef2 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScryptoSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ScryptoSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignallingValidator.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignallingValidator.java index 22b29aa878..0dc36e1ff7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignallingValidator.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignallingValidator.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Signature.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Signature.java index 1b3d028b34..4e054bdc1d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Signature.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Signature.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignatureWithPublicKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignatureWithPublicKey.java index 6f381cb4d1..0438bf6a92 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignatureWithPublicKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignatureWithPublicKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignedTransactionIntent.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignedTransactionIntent.java index 00784b9df8..9b64774878 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignedTransactionIntent.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignedTransactionIntent.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignificantProtocolUpdateReadinessEntry.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignificantProtocolUpdateReadinessEntry.java index 61d12ab512..d9626ca7a4 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignificantProtocolUpdateReadinessEntry.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SignificantProtocolUpdateReadinessEntry.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedIndexBlueprintCollectionSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedIndexBlueprintCollectionSchema.java index 667fff5278..b125fb44a3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedIndexBlueprintCollectionSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedIndexBlueprintCollectionSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedIndexBlueprintCollectionSchemaAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedIndexBlueprintCollectionSchemaAllOf.java index 865c93f705..43f898eceb 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedIndexBlueprintCollectionSchemaAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedIndexBlueprintCollectionSchemaAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedSubstateKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedSubstateKey.java index 2f22b4c97a..4f69797f08 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedSubstateKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedSubstateKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedSubstateKeyAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedSubstateKeyAllOf.java index 4d0615d2fe..c68c8345b7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedSubstateKeyAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SortedSubstateKeyAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccessControllerRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccessControllerRequest.java index a158e08500..a5cdef3836 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccessControllerRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccessControllerRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccessControllerResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccessControllerResponse.java index de67e4c644..167f31b3d2 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccessControllerResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccessControllerResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccountRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccountRequest.java index be460f44db..c78d20400d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccountRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccountRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccountResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccountResponse.java index 46e65602c6..7806023390 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccountResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateAccountResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentDescendentNode.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentDescendentNode.java index 8dbe34d165..6b0a8d61f1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentDescendentNode.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentDescendentNode.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentRequest.java index bc8fa97b86..239f3a1f6d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentResponse.java index cd1db20326..2056d0e24f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateComponentResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateConsensusManagerRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateConsensusManagerRequest.java index 60d471ca95..06dbaab268 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateConsensusManagerRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateConsensusManagerRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateConsensusManagerResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateConsensusManagerResponse.java index ee87b82f57..0cafcc10eb 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateConsensusManagerResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateConsensusManagerResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateFungibleResourceManager.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateFungibleResourceManager.java index b1c04ccdc3..a76369d81d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateFungibleResourceManager.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateFungibleResourceManager.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateFungibleResourceManagerAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateFungibleResourceManagerAllOf.java index bf16209fd7..1329423e9e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateFungibleResourceManagerAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateFungibleResourceManagerAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleRequest.java index 29992cf492..7ce6df91c6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResourceManager.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResourceManager.java index 09456d6bf7..7443a8450b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResourceManager.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResourceManager.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResourceManagerAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResourceManagerAllOf.java index 024a5cf014..70e5e047c0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResourceManagerAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResourceManagerAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResponse.java index 62cd34fc49..6f1e6bbf73 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateNonFungibleResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StatePackageRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StatePackageRequest.java index cfde993bc3..02ff8f5059 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StatePackageRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StatePackageRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StatePackageResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StatePackageResponse.java index a1c0844823..c40f122fc0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StatePackageResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StatePackageResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceManager.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceManager.java index f2657053f1..4712eb2544 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceManager.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceManager.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceRequest.java index 6e5f559f49..0d00924a47 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceResponse.java index e54114b08c..c3564067cf 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateResourceResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateUpdates.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateUpdates.java index 78362b446e..cb7b8a91e8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateUpdates.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateUpdates.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateValidatorRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateValidatorRequest.java index 2fa5667a16..9785023715 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateValidatorRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateValidatorRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateValidatorResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateValidatorResponse.java index 3728d0343e..6cf29e698b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateValidatorResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StateValidatorResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticBlueprintPayloadDef.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticBlueprintPayloadDef.java index e61a8b8649..b8df3495ec 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticBlueprintPayloadDef.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticBlueprintPayloadDef.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticBlueprintPayloadDefAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticBlueprintPayloadDefAllOf.java index 7bc281fffe..31aa20be9e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticBlueprintPayloadDefAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticBlueprintPayloadDefAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticRoleDefinitionAuthTemplate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticRoleDefinitionAuthTemplate.java index 35c3a25cca..1b6aac9f6d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticRoleDefinitionAuthTemplate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StaticRoleDefinitionAuthTemplate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetails.java index 13d5aa488e..3fd97d9742 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBounds.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBounds.java index 3da3fff287..58b9c0d244 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBounds.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBounds.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBoundsAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBoundsAllOf.java index c03617b297..e74604a365 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBoundsAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBoundsAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBounds.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBounds.java index afd851ea6b..50b1b73b0a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBounds.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBounds.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBoundsAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBoundsAllOf.java index 86fdb01a98..21aaba1b99 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBoundsAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBoundsAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsType.java index c3b8abb2b9..5b6aa73679 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorDetailsType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorResponse.java index 89c9c494d6..145dd7c0cd 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorResponseAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorResponseAllOf.java index b1030d605a..c2be597096 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorResponseAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsErrorResponseAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilter.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilter.java index 02dfaeb8d4..ecc0262123 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilter.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilter.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterAny.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterAny.java index 47f1c4330f..5d7508b203 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterAny.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterAny.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterAnyAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterAnyAllOf.java index ee56935c57..f344d15d1e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterAnyAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterAnyAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterNewEpochs.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterNewEpochs.java index c9861da950..06213f10aa 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterNewEpochs.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterNewEpochs.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterNewEpochsAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterNewEpochsAllOf.java index 570a523355..4f9d949c5e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterNewEpochsAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterNewEpochsAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateExecution.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateExecution.java index 2d648a8234..4ea8fc4d5f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateExecution.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateExecution.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateExecutionAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateExecutionAllOf.java index 265aee874f..9d49ebeadf 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateExecutionAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateExecutionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateInitializations.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateInitializations.java index 822f83e53a..30033e5894 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateInitializations.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterProtocolUpdateInitializations.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterType.java index 8fe561d07d..94fe6f495d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsFilterType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsRequest.java index c1c6a8bc7e..8a85d26057 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsResponse.java index 5fcc0eccc8..2758ffea33 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamProofsResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorDetails.java index 2c44952a15..a2c6493253 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorDetailsType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorDetailsType.java index 851b142530..7d36fe6a5a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorDetailsType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorDetailsType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorResponse.java index b85d5d1784..65c5fb486f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorResponseAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorResponseAllOf.java index e0ac365612..2783657587 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorResponseAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsErrorResponseAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsRequest.java index 44eeb9b0c6..fe591d02c1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsResponse.java index 65d5361e2c..02b72586b5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StreamTransactionsResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StringPlaintextMessageContent.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StringPlaintextMessageContent.java index aa628297c8..0848fd4cfa 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StringPlaintextMessageContent.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StringPlaintextMessageContent.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StringPlaintextMessageContentAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StringPlaintextMessageContentAllOf.java index d480de2d03..afc52e30c1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/StringPlaintextMessageContentAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/StringPlaintextMessageContentAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Substate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Substate.java index 90ef0a195b..145a47c1ac 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/Substate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/Substate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateFormatOptions.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateFormatOptions.java index 59da195fd6..fe38488441 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateFormatOptions.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateFormatOptions.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateId.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateId.java index a9efc626b8..e17926d860 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateId.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateId.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateIdAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateIdAllOf.java index fd08e8d4ce..02f344c567 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateIdAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateIdAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateKey.java index 41a79340b5..5785fdf069 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateKeyType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateKeyType.java index 1d5fd9580f..6c3e48b456 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateKeyType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateKeyType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateSystemStructure.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateSystemStructure.java index 902cabc8eb..32bf814245 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateSystemStructure.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateSystemStructure.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateSystemStructureType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateSystemStructureType.java index 553f46fde0..8463d54c0a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateSystemStructureType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateSystemStructureType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateType.java index 6d72cdc342..7cf9168c3a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateValue.java index 3408804a32..633ba60202 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SubstateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldKind.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldKind.java index 0bd8b70fec..cf3396ad17 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldKind.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldKind.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldStructure.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldStructure.java index 59e13f0e9f..4e14dc4e0a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldStructure.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldStructure.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldStructureAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldStructureAllOf.java index e34ea5ee46..dc1d64c7ff 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldStructureAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemFieldStructureAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemSchemaStructure.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemSchemaStructure.java index b170d88e7c..b27d35265a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemSchemaStructure.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemSchemaStructure.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemTransaction.java index 23a232ba3f..9af96cf47f 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/SystemTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TargetIdentifier.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TargetIdentifier.java index 1c7afdfbc7..50bcb8bb95 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TargetIdentifier.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TargetIdentifier.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TargetIdentifierType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TargetIdentifierType.java index 2f473af37f..135e547e72 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TargetIdentifierType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TargetIdentifierType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TimestampedValidatorSignature.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TimestampedValidatorSignature.java index edbb76b1c9..f5ab29efbb 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TimestampedValidatorSignature.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TimestampedValidatorSignature.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionCallPreviewRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionCallPreviewRequest.java index cb7ddc741d..ed72d0ce93 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionCallPreviewRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionCallPreviewRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionCallPreviewResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionCallPreviewResponse.java index 05bb2b7edb..1f11721617 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionCallPreviewResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionCallPreviewResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionFormatOptions.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionFormatOptions.java index 31865b8594..d9c35e4c0d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionFormatOptions.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionFormatOptions.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionHeader.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionHeader.java index cfe57efbc7..9a351e380e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionHeader.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionHeader.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIdKey.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIdKey.java index 60e20e30b7..72486aae43 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIdKey.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIdKey.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIdentifiers.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIdentifiers.java index 3a0ecfa93c..8ce684f38e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIdentifiers.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIdentifiers.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIntent.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIntent.java index 27634178d3..09e6212e0e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIntent.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIntent.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIntentStatus.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIntentStatus.java index ed33fc3d1a..034237b063 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIntentStatus.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionIntentStatus.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionMessage.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionMessage.java index db5f85fd27..3c5e762e2c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionMessage.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionMessage.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionMessageType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionMessageType.java index c99b4d1c46..f06923c331 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionMessageType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionMessageType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionParseRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionParseRequest.java index cba86fb09c..ecce9332c8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionParseRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionParseRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionParseResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionParseResponse.java index 1145b6bd62..df7236c403 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionParseResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionParseResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPayloadDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPayloadDetails.java index 02e9d4548e..fd4f4f93d3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPayloadDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPayloadDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPayloadStatus.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPayloadStatus.java index 2e51fed0fb..2adeb3f93a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPayloadStatus.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPayloadStatus.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewRequest.java index 609db79cc3..c7faaf4f2d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewRequestFlags.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewRequestFlags.java index 6956231f15..27a9b162e9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewRequestFlags.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewRequestFlags.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewResponse.java index 6657ff33cb..0bedbe4e12 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewResponseLogsInner.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewResponseLogsInner.java index 3d6293059c..989bb7c4ca 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewResponseLogsInner.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionPreviewResponseLogsInner.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceipt.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceipt.java index 18238ae5fa..f03fb8d14b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceipt.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceipt.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceiptRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceiptRequest.java index e90ac96164..7c4141dad9 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceiptRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceiptRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceiptResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceiptResponse.java index a628504e65..081de7ab02 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceiptResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionReceiptResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatus.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatus.java index 0b9586bc8b..ceb695e61a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatus.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatus.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatusRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatusRequest.java index 2cf077287e..3dc22cda7d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatusRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatusRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatusResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatusResponse.java index 9215345894..c688d0b83e 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatusResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionStatusResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorDetails.java index 54c7f460ac..214a7bb004 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorDetailsType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorDetailsType.java index ac67a22c1f..360e60abc1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorDetailsType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorDetailsType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorResponse.java index a5ce060577..3269ff3e97 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorResponseAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorResponseAllOf.java index 5fed465f18..72f17a41ba 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorResponseAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitErrorResponseAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitIntentAlreadyCommitted.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitIntentAlreadyCommitted.java index aafbbaaef6..46529bf0a6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitIntentAlreadyCommitted.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitIntentAlreadyCommitted.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitPriorityThresholdNotMetErrorDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitPriorityThresholdNotMetErrorDetails.java index 048e9e68c3..9fc2a93eb6 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitPriorityThresholdNotMetErrorDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitPriorityThresholdNotMetErrorDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitRejectedErrorDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitRejectedErrorDetails.java index 80c3bd7c7b..957a4994ca 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitRejectedErrorDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitRejectedErrorDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitRequest.java index 7b1cb6bc08..c00f8eb85b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitResponse.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitResponse.java index 29c2ca77c8..c442bb3a29 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitResponse.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionSubmitResponse.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntrySubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntrySubstate.java index 09958f72f3..c8c5431850 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntrySubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntrySubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntrySubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntrySubstateAllOf.java index e4e97b70ca..faa46cddc0 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntrySubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntrySubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntryValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntryValue.java index 61f1fc864f..ccbd4aaf1b 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntryValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerCollectionEntryValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateSubstate.java index 9a54a0e552..c0f21351f3 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateSubstateAllOf.java index 6b5dc2ff99..e69008951a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateValue.java index 15095e4384..72eac88710 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerTransactionStatus.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerTransactionStatus.java index cf3b7b875a..ed6e3f8a8d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerTransactionStatus.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TransactionTrackerTransactionStatus.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateSubstate.java index b1ad89ddfc..06d6aeb445 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateSubstateAllOf.java index b6154e260d..d25083dab7 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateValue.java index 8a3733bace..aa4b300fe5 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TwoResourcePoolFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoDetails.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoDetails.java index 42084b4660..df3477f9e1 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoDetails.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoDetails.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoSubstate.java index 39f39b7a74..b40807e853 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoSubstateAllOf.java index c0e4e2ca17..42cdd3e7fe 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoValue.java index def7d2aa4a..33d4cb5f4a 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoModuleFieldTypeInfoValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoType.java index e000e3a6e5..6eead46e6d 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/TypeInfoType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/UpdatedSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/UpdatedSubstate.java index 5a891e7800..e786eecd58 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/UpdatedSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/UpdatedSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/UserLedgerTransaction.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/UserLedgerTransaction.java index cd7d6abff8..7ea1a4b855 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/UserLedgerTransaction.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/UserLedgerTransaction.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/UserLedgerTransactionAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/UserLedgerTransactionAllOf.java index 8e45c94a9d..136ecf15ff 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/UserLedgerTransactionAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/UserLedgerTransactionAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFeeChangeRequest.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFeeChangeRequest.java index aa23a559b4..e3766c5210 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFeeChangeRequest.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFeeChangeRequest.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstate.java index 3941c78bb9..202d9a6188 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstateAllOf.java index f0632a994f..e952e2bc75 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalValue.java index c6cbdc6ab4..11fbd4af01 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldProtocolUpdateReadinessSignalValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateSubstate.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateSubstate.java index d26ded425a..6d90fa95be 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateSubstate.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateSubstate.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateSubstateAllOf.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateSubstateAllOf.java index 10e3f18bd9..4bb018eaf8 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateSubstateAllOf.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateSubstateAllOf.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateValue.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateValue.java index 1e4016375f..99ea404a31 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateValue.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/ValidatorFieldStateValue.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/VaultBalance.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/VaultBalance.java index 1008bb78cf..b6994d3c5c 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/VaultBalance.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/VaultBalance.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/VirtualLazyLoadSchema.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/VirtualLazyLoadSchema.java index 6f842abe3d..6069600730 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/VirtualLazyLoadSchema.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/VirtualLazyLoadSchema.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/core/src/test-core/java/com/radixdlt/api/core/generated/models/VmType.java b/core/src/test-core/java/com/radixdlt/api/core/generated/models/VmType.java index f1438d3ace..cc7fda2f35 100644 --- a/core/src/test-core/java/com/radixdlt/api/core/generated/models/VmType.java +++ b/core/src/test-core/java/com/radixdlt/api/core/generated/models/VmType.java @@ -1,8 +1,8 @@ /* - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node's current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/apis/LTSApi.ts b/sdk/typescript/lib/generated/apis/LTSApi.ts index e7e8006191..fc6ca248a5 100644 --- a/sdk/typescript/lib/generated/apis/LTSApi.ts +++ b/sdk/typescript/lib/generated/apis/LTSApi.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/apis/MempoolApi.ts b/sdk/typescript/lib/generated/apis/MempoolApi.ts index 43d5b95cdf..0390545c77 100644 --- a/sdk/typescript/lib/generated/apis/MempoolApi.ts +++ b/sdk/typescript/lib/generated/apis/MempoolApi.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/apis/StateApi.ts b/sdk/typescript/lib/generated/apis/StateApi.ts index b68dab5479..fa062a3362 100644 --- a/sdk/typescript/lib/generated/apis/StateApi.ts +++ b/sdk/typescript/lib/generated/apis/StateApi.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/apis/StatusApi.ts b/sdk/typescript/lib/generated/apis/StatusApi.ts index 01d1ea0365..6df179fe4a 100644 --- a/sdk/typescript/lib/generated/apis/StatusApi.ts +++ b/sdk/typescript/lib/generated/apis/StatusApi.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/apis/StreamApi.ts b/sdk/typescript/lib/generated/apis/StreamApi.ts index 2255794ab7..e8a9e5d62a 100644 --- a/sdk/typescript/lib/generated/apis/StreamApi.ts +++ b/sdk/typescript/lib/generated/apis/StreamApi.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/apis/TransactionApi.ts b/sdk/typescript/lib/generated/apis/TransactionApi.ts index e45f44a784..6a62867fc4 100644 --- a/sdk/typescript/lib/generated/apis/TransactionApi.ts +++ b/sdk/typescript/lib/generated/apis/TransactionApi.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccessControllerFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/AccessControllerFieldStateSubstate.ts index 3dd3026646..fbd8b571ab 100644 --- a/sdk/typescript/lib/generated/models/AccessControllerFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/AccessControllerFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccessControllerFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/AccessControllerFieldStateSubstateAllOf.ts index 70343f2d07..041ad72217 100644 --- a/sdk/typescript/lib/generated/models/AccessControllerFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/AccessControllerFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccessControllerFieldStateValue.ts b/sdk/typescript/lib/generated/models/AccessControllerFieldStateValue.ts index 04b813da5d..0633c125eb 100644 --- a/sdk/typescript/lib/generated/models/AccessControllerFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/AccessControllerFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccessRule.ts b/sdk/typescript/lib/generated/models/AccessRule.ts index d428f89d36..7b461bcaa4 100644 --- a/sdk/typescript/lib/generated/models/AccessRule.ts +++ b/sdk/typescript/lib/generated/models/AccessRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccessRuleBase.ts b/sdk/typescript/lib/generated/models/AccessRuleBase.ts index b4b7280588..741a0b5ecc 100644 --- a/sdk/typescript/lib/generated/models/AccessRuleBase.ts +++ b/sdk/typescript/lib/generated/models/AccessRuleBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccessRuleNode.ts b/sdk/typescript/lib/generated/models/AccessRuleNode.ts index af6f3630cb..11d3f37dc7 100644 --- a/sdk/typescript/lib/generated/models/AccessRuleNode.ts +++ b/sdk/typescript/lib/generated/models/AccessRuleNode.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccessRuleNodeBase.ts b/sdk/typescript/lib/generated/models/AccessRuleNodeBase.ts index a2a323389d..e12205dfc8 100644 --- a/sdk/typescript/lib/generated/models/AccessRuleNodeBase.ts +++ b/sdk/typescript/lib/generated/models/AccessRuleNodeBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccessRuleNodeType.ts b/sdk/typescript/lib/generated/models/AccessRuleNodeType.ts index d349a97048..f005c9edc9 100644 --- a/sdk/typescript/lib/generated/models/AccessRuleNodeType.ts +++ b/sdk/typescript/lib/generated/models/AccessRuleNodeType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccessRuleType.ts b/sdk/typescript/lib/generated/models/AccessRuleType.ts index 3fc64ee483..321f7f694b 100644 --- a/sdk/typescript/lib/generated/models/AccessRuleType.ts +++ b/sdk/typescript/lib/generated/models/AccessRuleType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntrySubstate.ts b/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntrySubstate.ts index b6ac1a63d1..7d922d7203 100644 --- a/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntrySubstateAllOf.ts index 6d973165b7..8b4699ed0d 100644 --- a/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntryValue.ts b/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntryValue.ts index 2416b6d54b..51bd91159d 100644 --- a/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntryValue.ts +++ b/sdk/typescript/lib/generated/models/AccountAuthorizedDepositorEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/AccountFieldStateSubstate.ts index badb5a5d14..89369cf653 100644 --- a/sdk/typescript/lib/generated/models/AccountFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/AccountFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/AccountFieldStateSubstateAllOf.ts index 21de3f3fa6..d699f293fd 100644 --- a/sdk/typescript/lib/generated/models/AccountFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/AccountFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountFieldStateValue.ts b/sdk/typescript/lib/generated/models/AccountFieldStateValue.ts index f468b5b7fe..187fd48cd2 100644 --- a/sdk/typescript/lib/generated/models/AccountFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/AccountFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntrySubstate.ts b/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntrySubstate.ts index e44c8d31a4..6622db47e0 100644 --- a/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntrySubstateAllOf.ts index f6c3cccb50..33dafcad59 100644 --- a/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntryValue.ts b/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntryValue.ts index 108fef5856..936ed086df 100644 --- a/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntryValue.ts +++ b/sdk/typescript/lib/generated/models/AccountResourcePreferenceEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountVaultEntrySubstate.ts b/sdk/typescript/lib/generated/models/AccountVaultEntrySubstate.ts index 81b5663729..b75054f1d4 100644 --- a/sdk/typescript/lib/generated/models/AccountVaultEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/AccountVaultEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountVaultEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/AccountVaultEntrySubstateAllOf.ts index 4abba5736b..202cf1291d 100644 --- a/sdk/typescript/lib/generated/models/AccountVaultEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/AccountVaultEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AccountVaultEntryValue.ts b/sdk/typescript/lib/generated/models/AccountVaultEntryValue.ts index bdc4032de9..8b41d999a6 100644 --- a/sdk/typescript/lib/generated/models/AccountVaultEntryValue.ts +++ b/sdk/typescript/lib/generated/models/AccountVaultEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ActiveValidator.ts b/sdk/typescript/lib/generated/models/ActiveValidator.ts index 88145a3e2b..e872809c14 100644 --- a/sdk/typescript/lib/generated/models/ActiveValidator.ts +++ b/sdk/typescript/lib/generated/models/ActiveValidator.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ActiveValidatorIndex.ts b/sdk/typescript/lib/generated/models/ActiveValidatorIndex.ts index 5e4da91f54..743773a1e1 100644 --- a/sdk/typescript/lib/generated/models/ActiveValidatorIndex.ts +++ b/sdk/typescript/lib/generated/models/ActiveValidatorIndex.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ActiveValidatorKey.ts b/sdk/typescript/lib/generated/models/ActiveValidatorKey.ts index 1fe3cea019..4ce971772d 100644 --- a/sdk/typescript/lib/generated/models/ActiveValidatorKey.ts +++ b/sdk/typescript/lib/generated/models/ActiveValidatorKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AddressType.ts b/sdk/typescript/lib/generated/models/AddressType.ts index 04bcb0c2d9..801f0682b8 100644 --- a/sdk/typescript/lib/generated/models/AddressType.ts +++ b/sdk/typescript/lib/generated/models/AddressType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AllOfAccessRuleNode.ts b/sdk/typescript/lib/generated/models/AllOfAccessRuleNode.ts index 759dace27b..0cd6f7b461 100644 --- a/sdk/typescript/lib/generated/models/AllOfAccessRuleNode.ts +++ b/sdk/typescript/lib/generated/models/AllOfAccessRuleNode.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AllOfAccessRuleNodeAllOf.ts b/sdk/typescript/lib/generated/models/AllOfAccessRuleNodeAllOf.ts index 5a7ab95f64..505b699d3f 100644 --- a/sdk/typescript/lib/generated/models/AllOfAccessRuleNodeAllOf.ts +++ b/sdk/typescript/lib/generated/models/AllOfAccessRuleNodeAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AllOfProofRule.ts b/sdk/typescript/lib/generated/models/AllOfProofRule.ts index ad4fd6ec59..0c964c0722 100644 --- a/sdk/typescript/lib/generated/models/AllOfProofRule.ts +++ b/sdk/typescript/lib/generated/models/AllOfProofRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AllOfProofRuleAllOf.ts b/sdk/typescript/lib/generated/models/AllOfProofRuleAllOf.ts index 3562bf99e6..952fdcdca5 100644 --- a/sdk/typescript/lib/generated/models/AllOfProofRuleAllOf.ts +++ b/sdk/typescript/lib/generated/models/AllOfProofRuleAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AllowAllAccessRule.ts b/sdk/typescript/lib/generated/models/AllowAllAccessRule.ts index 58646e77c8..9dd234fc53 100644 --- a/sdk/typescript/lib/generated/models/AllowAllAccessRule.ts +++ b/sdk/typescript/lib/generated/models/AllowAllAccessRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AllowAllAccessRuleAllOf.ts b/sdk/typescript/lib/generated/models/AllowAllAccessRuleAllOf.ts index 5cb429117d..29474d60b0 100644 --- a/sdk/typescript/lib/generated/models/AllowAllAccessRuleAllOf.ts +++ b/sdk/typescript/lib/generated/models/AllowAllAccessRuleAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AmountOfProofRule.ts b/sdk/typescript/lib/generated/models/AmountOfProofRule.ts index 65b656e5cd..743fa7484a 100644 --- a/sdk/typescript/lib/generated/models/AmountOfProofRule.ts +++ b/sdk/typescript/lib/generated/models/AmountOfProofRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AmountOfProofRuleAllOf.ts b/sdk/typescript/lib/generated/models/AmountOfProofRuleAllOf.ts index 5f34b94b2e..f85b3af35c 100644 --- a/sdk/typescript/lib/generated/models/AmountOfProofRuleAllOf.ts +++ b/sdk/typescript/lib/generated/models/AmountOfProofRuleAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AnyOfAccessRuleNode.ts b/sdk/typescript/lib/generated/models/AnyOfAccessRuleNode.ts index 9dadac5d2b..9eebf586cb 100644 --- a/sdk/typescript/lib/generated/models/AnyOfAccessRuleNode.ts +++ b/sdk/typescript/lib/generated/models/AnyOfAccessRuleNode.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AnyOfAccessRuleNodeAllOf.ts b/sdk/typescript/lib/generated/models/AnyOfAccessRuleNodeAllOf.ts index 51556dea7a..64b92dd993 100644 --- a/sdk/typescript/lib/generated/models/AnyOfAccessRuleNodeAllOf.ts +++ b/sdk/typescript/lib/generated/models/AnyOfAccessRuleNodeAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AnyOfProofRule.ts b/sdk/typescript/lib/generated/models/AnyOfProofRule.ts index d45f84426b..a95d067947 100644 --- a/sdk/typescript/lib/generated/models/AnyOfProofRule.ts +++ b/sdk/typescript/lib/generated/models/AnyOfProofRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AnyOfProofRuleAllOf.ts b/sdk/typescript/lib/generated/models/AnyOfProofRuleAllOf.ts index 695619fce8..d95cd91a28 100644 --- a/sdk/typescript/lib/generated/models/AnyOfProofRuleAllOf.ts +++ b/sdk/typescript/lib/generated/models/AnyOfProofRuleAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AttachedModuleId.ts b/sdk/typescript/lib/generated/models/AttachedModuleId.ts index 9d846c5820..d2949244a6 100644 --- a/sdk/typescript/lib/generated/models/AttachedModuleId.ts +++ b/sdk/typescript/lib/generated/models/AttachedModuleId.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AuthConfig.ts b/sdk/typescript/lib/generated/models/AuthConfig.ts index a1dbb77c17..01f6e2212f 100644 --- a/sdk/typescript/lib/generated/models/AuthConfig.ts +++ b/sdk/typescript/lib/generated/models/AuthConfig.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AuthorizedDepositorBadge.ts b/sdk/typescript/lib/generated/models/AuthorizedDepositorBadge.ts index 47e0e0efdc..fa5d57edde 100644 --- a/sdk/typescript/lib/generated/models/AuthorizedDepositorBadge.ts +++ b/sdk/typescript/lib/generated/models/AuthorizedDepositorBadge.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AuthorizedDepositorBadgeBase.ts b/sdk/typescript/lib/generated/models/AuthorizedDepositorBadgeBase.ts index 1856b18233..f7f2710d7a 100644 --- a/sdk/typescript/lib/generated/models/AuthorizedDepositorBadgeBase.ts +++ b/sdk/typescript/lib/generated/models/AuthorizedDepositorBadgeBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AuthorizedDepositorBadgeType.ts b/sdk/typescript/lib/generated/models/AuthorizedDepositorBadgeType.ts index 28ca49aba0..d247d47f78 100644 --- a/sdk/typescript/lib/generated/models/AuthorizedDepositorBadgeType.ts +++ b/sdk/typescript/lib/generated/models/AuthorizedDepositorBadgeType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/AuthorizedDepositorKey.ts b/sdk/typescript/lib/generated/models/AuthorizedDepositorKey.ts index cb4c17f52b..91390ed4f9 100644 --- a/sdk/typescript/lib/generated/models/AuthorizedDepositorKey.ts +++ b/sdk/typescript/lib/generated/models/AuthorizedDepositorKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BasicErrorResponse.ts b/sdk/typescript/lib/generated/models/BasicErrorResponse.ts index f70caa6680..ff082c7e31 100644 --- a/sdk/typescript/lib/generated/models/BasicErrorResponse.ts +++ b/sdk/typescript/lib/generated/models/BasicErrorResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BasicErrorResponseAllOf.ts b/sdk/typescript/lib/generated/models/BasicErrorResponseAllOf.ts index c4f2109134..856597d21e 100644 --- a/sdk/typescript/lib/generated/models/BasicErrorResponseAllOf.ts +++ b/sdk/typescript/lib/generated/models/BasicErrorResponseAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BinaryPlaintextMessageContent.ts b/sdk/typescript/lib/generated/models/BinaryPlaintextMessageContent.ts index 08bc998975..1975d36133 100644 --- a/sdk/typescript/lib/generated/models/BinaryPlaintextMessageContent.ts +++ b/sdk/typescript/lib/generated/models/BinaryPlaintextMessageContent.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BinaryPlaintextMessageContentAllOf.ts b/sdk/typescript/lib/generated/models/BinaryPlaintextMessageContentAllOf.ts index d7872e9f5a..60e787706f 100644 --- a/sdk/typescript/lib/generated/models/BinaryPlaintextMessageContentAllOf.ts +++ b/sdk/typescript/lib/generated/models/BinaryPlaintextMessageContentAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintCollectionSchema.ts b/sdk/typescript/lib/generated/models/BlueprintCollectionSchema.ts index 52748c035a..8cb28d712c 100644 --- a/sdk/typescript/lib/generated/models/BlueprintCollectionSchema.ts +++ b/sdk/typescript/lib/generated/models/BlueprintCollectionSchema.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintCollectionSchemaBase.ts b/sdk/typescript/lib/generated/models/BlueprintCollectionSchemaBase.ts index 9a70d9e34b..565909dc02 100644 --- a/sdk/typescript/lib/generated/models/BlueprintCollectionSchemaBase.ts +++ b/sdk/typescript/lib/generated/models/BlueprintCollectionSchemaBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintCollectionSchemaType.ts b/sdk/typescript/lib/generated/models/BlueprintCollectionSchemaType.ts index 753365ff73..ffd45d93d2 100644 --- a/sdk/typescript/lib/generated/models/BlueprintCollectionSchemaType.ts +++ b/sdk/typescript/lib/generated/models/BlueprintCollectionSchemaType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintDefinition.ts b/sdk/typescript/lib/generated/models/BlueprintDefinition.ts index a1ae538cbb..3f15ac1511 100644 --- a/sdk/typescript/lib/generated/models/BlueprintDefinition.ts +++ b/sdk/typescript/lib/generated/models/BlueprintDefinition.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintDependencies.ts b/sdk/typescript/lib/generated/models/BlueprintDependencies.ts index 1fcbc0fa7f..6e7fb993e0 100644 --- a/sdk/typescript/lib/generated/models/BlueprintDependencies.ts +++ b/sdk/typescript/lib/generated/models/BlueprintDependencies.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintFunctionTargetIdentifier.ts b/sdk/typescript/lib/generated/models/BlueprintFunctionTargetIdentifier.ts index 8814c38796..93f994b6b0 100644 --- a/sdk/typescript/lib/generated/models/BlueprintFunctionTargetIdentifier.ts +++ b/sdk/typescript/lib/generated/models/BlueprintFunctionTargetIdentifier.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintFunctionTargetIdentifierAllOf.ts b/sdk/typescript/lib/generated/models/BlueprintFunctionTargetIdentifierAllOf.ts index 7d8a9107e9..219e466eb3 100644 --- a/sdk/typescript/lib/generated/models/BlueprintFunctionTargetIdentifierAllOf.ts +++ b/sdk/typescript/lib/generated/models/BlueprintFunctionTargetIdentifierAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintInfo.ts b/sdk/typescript/lib/generated/models/BlueprintInfo.ts index 28a1cfc413..6306de0f26 100644 --- a/sdk/typescript/lib/generated/models/BlueprintInfo.ts +++ b/sdk/typescript/lib/generated/models/BlueprintInfo.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintInterface.ts b/sdk/typescript/lib/generated/models/BlueprintInterface.ts index 6b63de604b..0267f7dd69 100644 --- a/sdk/typescript/lib/generated/models/BlueprintInterface.ts +++ b/sdk/typescript/lib/generated/models/BlueprintInterface.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintMethodRoyalty.ts b/sdk/typescript/lib/generated/models/BlueprintMethodRoyalty.ts index 81366151f7..7ebc0b03d7 100644 --- a/sdk/typescript/lib/generated/models/BlueprintMethodRoyalty.ts +++ b/sdk/typescript/lib/generated/models/BlueprintMethodRoyalty.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintPayloadDef.ts b/sdk/typescript/lib/generated/models/BlueprintPayloadDef.ts index a2339595ab..1277c6c01a 100644 --- a/sdk/typescript/lib/generated/models/BlueprintPayloadDef.ts +++ b/sdk/typescript/lib/generated/models/BlueprintPayloadDef.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintPayloadDefBase.ts b/sdk/typescript/lib/generated/models/BlueprintPayloadDefBase.ts index 3b8174b4e9..3aeb70c70b 100644 --- a/sdk/typescript/lib/generated/models/BlueprintPayloadDefBase.ts +++ b/sdk/typescript/lib/generated/models/BlueprintPayloadDefBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintPayloadDefType.ts b/sdk/typescript/lib/generated/models/BlueprintPayloadDefType.ts index 5fabd596c7..e74bae85d0 100644 --- a/sdk/typescript/lib/generated/models/BlueprintPayloadDefType.ts +++ b/sdk/typescript/lib/generated/models/BlueprintPayloadDefType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintRoyaltyConfig.ts b/sdk/typescript/lib/generated/models/BlueprintRoyaltyConfig.ts index 6889038255..50613713d5 100644 --- a/sdk/typescript/lib/generated/models/BlueprintRoyaltyConfig.ts +++ b/sdk/typescript/lib/generated/models/BlueprintRoyaltyConfig.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintSchemaBlueprintTypeReference.ts b/sdk/typescript/lib/generated/models/BlueprintSchemaBlueprintTypeReference.ts index aa43c05277..2f2004cd6d 100644 --- a/sdk/typescript/lib/generated/models/BlueprintSchemaBlueprintTypeReference.ts +++ b/sdk/typescript/lib/generated/models/BlueprintSchemaBlueprintTypeReference.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintSchemaBlueprintTypeReferenceAllOf.ts b/sdk/typescript/lib/generated/models/BlueprintSchemaBlueprintTypeReferenceAllOf.ts index d5562defb0..2209325208 100644 --- a/sdk/typescript/lib/generated/models/BlueprintSchemaBlueprintTypeReferenceAllOf.ts +++ b/sdk/typescript/lib/generated/models/BlueprintSchemaBlueprintTypeReferenceAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintSchemaCollectionPartition.ts b/sdk/typescript/lib/generated/models/BlueprintSchemaCollectionPartition.ts index 52464cf1a3..5855871684 100644 --- a/sdk/typescript/lib/generated/models/BlueprintSchemaCollectionPartition.ts +++ b/sdk/typescript/lib/generated/models/BlueprintSchemaCollectionPartition.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintSchemaFieldPartition.ts b/sdk/typescript/lib/generated/models/BlueprintSchemaFieldPartition.ts index d88374c29f..202bf7c880 100644 --- a/sdk/typescript/lib/generated/models/BlueprintSchemaFieldPartition.ts +++ b/sdk/typescript/lib/generated/models/BlueprintSchemaFieldPartition.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintTypeIdentifier.ts b/sdk/typescript/lib/generated/models/BlueprintTypeIdentifier.ts index 22f9a28c0b..d6fce622ff 100644 --- a/sdk/typescript/lib/generated/models/BlueprintTypeIdentifier.ts +++ b/sdk/typescript/lib/generated/models/BlueprintTypeIdentifier.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintTypeReference.ts b/sdk/typescript/lib/generated/models/BlueprintTypeReference.ts index d0f0690342..75c2ce25fd 100644 --- a/sdk/typescript/lib/generated/models/BlueprintTypeReference.ts +++ b/sdk/typescript/lib/generated/models/BlueprintTypeReference.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintTypeReferenceBase.ts b/sdk/typescript/lib/generated/models/BlueprintTypeReferenceBase.ts index 0e6ebb6075..d894420ce3 100644 --- a/sdk/typescript/lib/generated/models/BlueprintTypeReferenceBase.ts +++ b/sdk/typescript/lib/generated/models/BlueprintTypeReferenceBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintTypeReferenceKind.ts b/sdk/typescript/lib/generated/models/BlueprintTypeReferenceKind.ts index a5393d18d3..ebf50222b5 100644 --- a/sdk/typescript/lib/generated/models/BlueprintTypeReferenceKind.ts +++ b/sdk/typescript/lib/generated/models/BlueprintTypeReferenceKind.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BlueprintVersionKey.ts b/sdk/typescript/lib/generated/models/BlueprintVersionKey.ts index 4fcec4185b..c6c4bf6672 100644 --- a/sdk/typescript/lib/generated/models/BlueprintVersionKey.ts +++ b/sdk/typescript/lib/generated/models/BlueprintVersionKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootSubstate.ts b/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootSubstate.ts index e7a0bbdf85..345116f613 100644 --- a/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootSubstate.ts +++ b/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootSubstateAllOf.ts b/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootSubstateAllOf.ts index 55551c2930..55badac5bf 100644 --- a/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootValue.ts b/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootValue.ts index 770d641a8d..0aa99417a5 100644 --- a/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootValue.ts +++ b/sdk/typescript/lib/generated/models/BootLoaderModuleFieldVmBootValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/CommittedIntentMetadata.ts b/sdk/typescript/lib/generated/models/CommittedIntentMetadata.ts index 1738d3457b..0cdfa3d570 100644 --- a/sdk/typescript/lib/generated/models/CommittedIntentMetadata.ts +++ b/sdk/typescript/lib/generated/models/CommittedIntentMetadata.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/CommittedStateIdentifier.ts b/sdk/typescript/lib/generated/models/CommittedStateIdentifier.ts index ba472bfde3..6ba02115d8 100644 --- a/sdk/typescript/lib/generated/models/CommittedStateIdentifier.ts +++ b/sdk/typescript/lib/generated/models/CommittedStateIdentifier.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/CommittedStateIdentifierAllOf.ts b/sdk/typescript/lib/generated/models/CommittedStateIdentifierAllOf.ts index bfa3082795..e6cb697c13 100644 --- a/sdk/typescript/lib/generated/models/CommittedStateIdentifierAllOf.ts +++ b/sdk/typescript/lib/generated/models/CommittedStateIdentifierAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/CommittedTransaction.ts b/sdk/typescript/lib/generated/models/CommittedTransaction.ts index 4472f21c8c..308bb6fa80 100644 --- a/sdk/typescript/lib/generated/models/CommittedTransaction.ts +++ b/sdk/typescript/lib/generated/models/CommittedTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/CommittedTransactionBalanceChanges.ts b/sdk/typescript/lib/generated/models/CommittedTransactionBalanceChanges.ts index 1ca4310905..7cbfb16ef9 100644 --- a/sdk/typescript/lib/generated/models/CommittedTransactionBalanceChanges.ts +++ b/sdk/typescript/lib/generated/models/CommittedTransactionBalanceChanges.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ComponentMethodTargetIdentifier.ts b/sdk/typescript/lib/generated/models/ComponentMethodTargetIdentifier.ts index 016de77c59..2ff5334da9 100644 --- a/sdk/typescript/lib/generated/models/ComponentMethodTargetIdentifier.ts +++ b/sdk/typescript/lib/generated/models/ComponentMethodTargetIdentifier.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ComponentMethodTargetIdentifierAllOf.ts b/sdk/typescript/lib/generated/models/ComponentMethodTargetIdentifierAllOf.ts index 86650e8de4..dfc02791da 100644 --- a/sdk/typescript/lib/generated/models/ComponentMethodTargetIdentifierAllOf.ts +++ b/sdk/typescript/lib/generated/models/ComponentMethodTargetIdentifierAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusLedgerProofOrigin.ts b/sdk/typescript/lib/generated/models/ConsensusLedgerProofOrigin.ts index b1f8401a2d..da8ab11d65 100644 --- a/sdk/typescript/lib/generated/models/ConsensusLedgerProofOrigin.ts +++ b/sdk/typescript/lib/generated/models/ConsensusLedgerProofOrigin.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusLedgerProofOriginAllOf.ts b/sdk/typescript/lib/generated/models/ConsensusLedgerProofOriginAllOf.ts index e0f5e6c578..58ed4f0894 100644 --- a/sdk/typescript/lib/generated/models/ConsensusLedgerProofOriginAllOf.ts +++ b/sdk/typescript/lib/generated/models/ConsensusLedgerProofOriginAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigSubstate.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigSubstate.ts index 4108e71244..75013bcb68 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigSubstate.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigSubstateAllOf.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigSubstateAllOf.ts index 432ca8ab22..92d200f3b0 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigValue.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigValue.ts index d9284038ce..375267581c 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigValue.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldConfigValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstate.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstate.ts index 64ee94bb02..a5817c506b 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstate.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstateAllOf.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstateAllOf.ts index 15eef31e46..215cc3afc2 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticValue.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticValue.ts index 51b5fc94c2..4338e93274 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticValue.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentProposalStatisticValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstate.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstate.ts index ce0ead5346..5bb595e556 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstate.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstateAllOf.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstateAllOf.ts index 8e37e36c96..d2b2f246c0 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesValue.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesValue.ts index 012ca4a163..e7cec80215 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesValue.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeRoundedToMinutesValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeSubstate.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeSubstate.ts index cd7b56d476..b4c67a7064 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeSubstate.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeSubstateAllOf.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeSubstateAllOf.ts index 92c139ee07..3394d44c4e 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeValue.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeValue.ts index b79691b227..8ea47f2dab 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeValue.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentTimeValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstate.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstate.ts index f228fa2d27..d0126ef680 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstate.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstateAllOf.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstateAllOf.ts index 7efa1b2708..d253eddfa6 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetValue.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetValue.ts index b40b77203e..6a8dbdb049 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetValue.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldCurrentValidatorSetValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateSubstate.ts index b5f5ff2abd..2b80e892b6 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateSubstateAllOf.ts index 1cfd3845ce..6d86f845d4 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateValue.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateValue.ts index ed31f2d773..9dece5f689 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsSubstate.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsSubstate.ts index 74b9e53a13..d582c5422b 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsSubstate.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsSubstateAllOf.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsSubstateAllOf.ts index 93f07c05fb..4c8232cfc6 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsValue.ts b/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsValue.ts index b7c5940f33..4bc4046fa1 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsValue.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerFieldValidatorRewardsValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstate.ts b/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstate.ts index f74b152661..b39a0365b4 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstateAllOf.ts index 65190b508c..f27e7f4a64 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntryValue.ts b/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntryValue.ts index 401c5f1bb7..7f81591736 100644 --- a/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntryValue.ts +++ b/sdk/typescript/lib/generated/models/ConsensusManagerRegisteredValidatorsByStakeIndexEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/CostingParameters.ts b/sdk/typescript/lib/generated/models/CostingParameters.ts index 37de91d6b1..34004ba013 100644 --- a/sdk/typescript/lib/generated/models/CostingParameters.ts +++ b/sdk/typescript/lib/generated/models/CostingParameters.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/CountOfProofRule.ts b/sdk/typescript/lib/generated/models/CountOfProofRule.ts index 9735fede67..3c9d86d3b9 100644 --- a/sdk/typescript/lib/generated/models/CountOfProofRule.ts +++ b/sdk/typescript/lib/generated/models/CountOfProofRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/CountOfProofRuleAllOf.ts b/sdk/typescript/lib/generated/models/CountOfProofRuleAllOf.ts index 0af257863e..917ce51e51 100644 --- a/sdk/typescript/lib/generated/models/CountOfProofRuleAllOf.ts +++ b/sdk/typescript/lib/generated/models/CountOfProofRuleAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/CreatedSubstate.ts b/sdk/typescript/lib/generated/models/CreatedSubstate.ts index 16b6579d78..70607183da 100644 --- a/sdk/typescript/lib/generated/models/CreatedSubstate.ts +++ b/sdk/typescript/lib/generated/models/CreatedSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/DataStruct.ts b/sdk/typescript/lib/generated/models/DataStruct.ts index d7c5149a6f..0950ff028d 100644 --- a/sdk/typescript/lib/generated/models/DataStruct.ts +++ b/sdk/typescript/lib/generated/models/DataStruct.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/DefaultDepositRule.ts b/sdk/typescript/lib/generated/models/DefaultDepositRule.ts index ef00e40e7c..5811786075 100644 --- a/sdk/typescript/lib/generated/models/DefaultDepositRule.ts +++ b/sdk/typescript/lib/generated/models/DefaultDepositRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/DeletedSubstate.ts b/sdk/typescript/lib/generated/models/DeletedSubstate.ts index 8bc35eea69..a1e2fa7d29 100644 --- a/sdk/typescript/lib/generated/models/DeletedSubstate.ts +++ b/sdk/typescript/lib/generated/models/DeletedSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/DenyAllAccessRule.ts b/sdk/typescript/lib/generated/models/DenyAllAccessRule.ts index bdde0e17f5..e3b6ea26de 100644 --- a/sdk/typescript/lib/generated/models/DenyAllAccessRule.ts +++ b/sdk/typescript/lib/generated/models/DenyAllAccessRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/DenyAllAccessRuleAllOf.ts b/sdk/typescript/lib/generated/models/DenyAllAccessRuleAllOf.ts index 68a5beba8b..048cc5c268 100644 --- a/sdk/typescript/lib/generated/models/DenyAllAccessRuleAllOf.ts +++ b/sdk/typescript/lib/generated/models/DenyAllAccessRuleAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EcdsaSecp256k1PublicKey.ts b/sdk/typescript/lib/generated/models/EcdsaSecp256k1PublicKey.ts index b42be6a82c..2a6f9f96a4 100644 --- a/sdk/typescript/lib/generated/models/EcdsaSecp256k1PublicKey.ts +++ b/sdk/typescript/lib/generated/models/EcdsaSecp256k1PublicKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EcdsaSecp256k1PublicKeyAllOf.ts b/sdk/typescript/lib/generated/models/EcdsaSecp256k1PublicKeyAllOf.ts index 3d7f6233ed..2544fa4ba1 100644 --- a/sdk/typescript/lib/generated/models/EcdsaSecp256k1PublicKeyAllOf.ts +++ b/sdk/typescript/lib/generated/models/EcdsaSecp256k1PublicKeyAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EcdsaSecp256k1Signature.ts b/sdk/typescript/lib/generated/models/EcdsaSecp256k1Signature.ts index e8733f7ecd..033b1eaa30 100644 --- a/sdk/typescript/lib/generated/models/EcdsaSecp256k1Signature.ts +++ b/sdk/typescript/lib/generated/models/EcdsaSecp256k1Signature.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureAllOf.ts b/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureAllOf.ts index 9ad696d9ac..2fa5353091 100644 --- a/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureAllOf.ts +++ b/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureWithPublicKey.ts b/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureWithPublicKey.ts index 3337a1ac35..63c68871dc 100644 --- a/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureWithPublicKey.ts +++ b/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureWithPublicKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureWithPublicKeyAllOf.ts b/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureWithPublicKeyAllOf.ts index 4f6958382a..bd9a67475c 100644 --- a/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureWithPublicKeyAllOf.ts +++ b/sdk/typescript/lib/generated/models/EcdsaSecp256k1SignatureWithPublicKeyAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EddsaEd25519PublicKey.ts b/sdk/typescript/lib/generated/models/EddsaEd25519PublicKey.ts index 540581292e..7a5ba18776 100644 --- a/sdk/typescript/lib/generated/models/EddsaEd25519PublicKey.ts +++ b/sdk/typescript/lib/generated/models/EddsaEd25519PublicKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EddsaEd25519PublicKeyAllOf.ts b/sdk/typescript/lib/generated/models/EddsaEd25519PublicKeyAllOf.ts index 2baf1f1897..a2878f62e6 100644 --- a/sdk/typescript/lib/generated/models/EddsaEd25519PublicKeyAllOf.ts +++ b/sdk/typescript/lib/generated/models/EddsaEd25519PublicKeyAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EddsaEd25519Signature.ts b/sdk/typescript/lib/generated/models/EddsaEd25519Signature.ts index d50e54b737..bfeac3b53e 100644 --- a/sdk/typescript/lib/generated/models/EddsaEd25519Signature.ts +++ b/sdk/typescript/lib/generated/models/EddsaEd25519Signature.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EddsaEd25519SignatureAllOf.ts b/sdk/typescript/lib/generated/models/EddsaEd25519SignatureAllOf.ts index e7e78867e7..fa791b1db0 100644 --- a/sdk/typescript/lib/generated/models/EddsaEd25519SignatureAllOf.ts +++ b/sdk/typescript/lib/generated/models/EddsaEd25519SignatureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EddsaEd25519SignatureWithPublicKey.ts b/sdk/typescript/lib/generated/models/EddsaEd25519SignatureWithPublicKey.ts index bab3a5bbae..8d56b83051 100644 --- a/sdk/typescript/lib/generated/models/EddsaEd25519SignatureWithPublicKey.ts +++ b/sdk/typescript/lib/generated/models/EddsaEd25519SignatureWithPublicKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EddsaEd25519SignatureWithPublicKeyAllOf.ts b/sdk/typescript/lib/generated/models/EddsaEd25519SignatureWithPublicKeyAllOf.ts index fa83f83bb5..7c9060b70f 100644 --- a/sdk/typescript/lib/generated/models/EddsaEd25519SignatureWithPublicKeyAllOf.ts +++ b/sdk/typescript/lib/generated/models/EddsaEd25519SignatureWithPublicKeyAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EncryptedMessageCurveDecryptorSet.ts b/sdk/typescript/lib/generated/models/EncryptedMessageCurveDecryptorSet.ts index 99b5ca572f..a6ce6e1977 100644 --- a/sdk/typescript/lib/generated/models/EncryptedMessageCurveDecryptorSet.ts +++ b/sdk/typescript/lib/generated/models/EncryptedMessageCurveDecryptorSet.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EncryptedMessageDecryptor.ts b/sdk/typescript/lib/generated/models/EncryptedMessageDecryptor.ts index 379dcf5a3c..2cf3034640 100644 --- a/sdk/typescript/lib/generated/models/EncryptedMessageDecryptor.ts +++ b/sdk/typescript/lib/generated/models/EncryptedMessageDecryptor.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EncryptedTransactionMessage.ts b/sdk/typescript/lib/generated/models/EncryptedTransactionMessage.ts index 15927acf9c..e73a2b1d52 100644 --- a/sdk/typescript/lib/generated/models/EncryptedTransactionMessage.ts +++ b/sdk/typescript/lib/generated/models/EncryptedTransactionMessage.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EncryptedTransactionMessageAllOf.ts b/sdk/typescript/lib/generated/models/EncryptedTransactionMessageAllOf.ts index 703fd75d28..eff6c32d0a 100644 --- a/sdk/typescript/lib/generated/models/EncryptedTransactionMessageAllOf.ts +++ b/sdk/typescript/lib/generated/models/EncryptedTransactionMessageAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EntityModule.ts b/sdk/typescript/lib/generated/models/EntityModule.ts index 9c8d903ceb..7777285d8a 100644 --- a/sdk/typescript/lib/generated/models/EntityModule.ts +++ b/sdk/typescript/lib/generated/models/EntityModule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EntityReference.ts b/sdk/typescript/lib/generated/models/EntityReference.ts index 3f4b7e88ea..8da1776b8b 100644 --- a/sdk/typescript/lib/generated/models/EntityReference.ts +++ b/sdk/typescript/lib/generated/models/EntityReference.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EntityType.ts b/sdk/typescript/lib/generated/models/EntityType.ts index 09725b2915..420eabbde3 100644 --- a/sdk/typescript/lib/generated/models/EntityType.ts +++ b/sdk/typescript/lib/generated/models/EntityType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EpochChangeCondition.ts b/sdk/typescript/lib/generated/models/EpochChangeCondition.ts index afb76623d0..d9be8238d3 100644 --- a/sdk/typescript/lib/generated/models/EpochChangeCondition.ts +++ b/sdk/typescript/lib/generated/models/EpochChangeCondition.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EpochEndLedgerProof.ts b/sdk/typescript/lib/generated/models/EpochEndLedgerProof.ts index a297c64ba9..964f76e43a 100644 --- a/sdk/typescript/lib/generated/models/EpochEndLedgerProof.ts +++ b/sdk/typescript/lib/generated/models/EpochEndLedgerProof.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EpochRound.ts b/sdk/typescript/lib/generated/models/EpochRound.ts index 801c6154e7..6f3109f5aa 100644 --- a/sdk/typescript/lib/generated/models/EpochRound.ts +++ b/sdk/typescript/lib/generated/models/EpochRound.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ErrorResponse.ts b/sdk/typescript/lib/generated/models/ErrorResponse.ts index be87dd1d9b..29d7c06ed9 100644 --- a/sdk/typescript/lib/generated/models/ErrorResponse.ts +++ b/sdk/typescript/lib/generated/models/ErrorResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ErrorResponseBase.ts b/sdk/typescript/lib/generated/models/ErrorResponseBase.ts index ae81e121c4..e17c735e52 100644 --- a/sdk/typescript/lib/generated/models/ErrorResponseBase.ts +++ b/sdk/typescript/lib/generated/models/ErrorResponseBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ErrorResponseType.ts b/sdk/typescript/lib/generated/models/ErrorResponseType.ts index d4ac8bab2c..6deb5f761d 100644 --- a/sdk/typescript/lib/generated/models/ErrorResponseType.ts +++ b/sdk/typescript/lib/generated/models/ErrorResponseType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/Event.ts b/sdk/typescript/lib/generated/models/Event.ts index 6c7b35fa9b..9f6b8fe9fb 100644 --- a/sdk/typescript/lib/generated/models/Event.ts +++ b/sdk/typescript/lib/generated/models/Event.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EventEmitterIdentifier.ts b/sdk/typescript/lib/generated/models/EventEmitterIdentifier.ts index 55f0ec0e5b..bd285a18c5 100644 --- a/sdk/typescript/lib/generated/models/EventEmitterIdentifier.ts +++ b/sdk/typescript/lib/generated/models/EventEmitterIdentifier.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EventEmitterIdentifierBase.ts b/sdk/typescript/lib/generated/models/EventEmitterIdentifierBase.ts index 5259341166..91e557bf77 100644 --- a/sdk/typescript/lib/generated/models/EventEmitterIdentifierBase.ts +++ b/sdk/typescript/lib/generated/models/EventEmitterIdentifierBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EventEmitterIdentifierType.ts b/sdk/typescript/lib/generated/models/EventEmitterIdentifierType.ts index 6bc1e52169..b22b3da560 100644 --- a/sdk/typescript/lib/generated/models/EventEmitterIdentifierType.ts +++ b/sdk/typescript/lib/generated/models/EventEmitterIdentifierType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/EventTypeIdentifier.ts b/sdk/typescript/lib/generated/models/EventTypeIdentifier.ts index ac3d987b72..a5f7257bbf 100644 --- a/sdk/typescript/lib/generated/models/EventTypeIdentifier.ts +++ b/sdk/typescript/lib/generated/models/EventTypeIdentifier.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ExecutedGenesisScenario.ts b/sdk/typescript/lib/generated/models/ExecutedGenesisScenario.ts index 5e5f4709b1..740bb27625 100644 --- a/sdk/typescript/lib/generated/models/ExecutedGenesisScenario.ts +++ b/sdk/typescript/lib/generated/models/ExecutedGenesisScenario.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ExecutedScenarioTransaction.ts b/sdk/typescript/lib/generated/models/ExecutedScenarioTransaction.ts index 3db6e63550..dde64b7da0 100644 --- a/sdk/typescript/lib/generated/models/ExecutedScenarioTransaction.ts +++ b/sdk/typescript/lib/generated/models/ExecutedScenarioTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FeeDestination.ts b/sdk/typescript/lib/generated/models/FeeDestination.ts index b60a207a37..b06d2d392c 100644 --- a/sdk/typescript/lib/generated/models/FeeDestination.ts +++ b/sdk/typescript/lib/generated/models/FeeDestination.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FeeSource.ts b/sdk/typescript/lib/generated/models/FeeSource.ts index 1789bf3e05..7d7c9ff7ca 100644 --- a/sdk/typescript/lib/generated/models/FeeSource.ts +++ b/sdk/typescript/lib/generated/models/FeeSource.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FeeSummary.ts b/sdk/typescript/lib/generated/models/FeeSummary.ts index 4588269033..519127d8c6 100644 --- a/sdk/typescript/lib/generated/models/FeeSummary.ts +++ b/sdk/typescript/lib/generated/models/FeeSummary.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchema.ts b/sdk/typescript/lib/generated/models/FieldSchema.ts index 958407fda9..3315461078 100644 --- a/sdk/typescript/lib/generated/models/FieldSchema.ts +++ b/sdk/typescript/lib/generated/models/FieldSchema.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchemaFeatureCondition.ts b/sdk/typescript/lib/generated/models/FieldSchemaFeatureCondition.ts index 9ae73de10e..a490da4c47 100644 --- a/sdk/typescript/lib/generated/models/FieldSchemaFeatureCondition.ts +++ b/sdk/typescript/lib/generated/models/FieldSchemaFeatureCondition.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionAlways.ts b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionAlways.ts index 8641061714..3507763887 100644 --- a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionAlways.ts +++ b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionAlways.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionAlwaysAllOf.ts b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionAlwaysAllOf.ts index d03422d21d..3c0d7eb97b 100644 --- a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionAlwaysAllOf.ts +++ b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionAlwaysAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionBase.ts b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionBase.ts index 7e525189e8..c100cdbc63 100644 --- a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionBase.ts +++ b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeature.ts b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeature.ts index a40af89500..6e8f2122d9 100644 --- a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeature.ts +++ b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeature.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeatureAllOf.ts b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeatureAllOf.ts index dee42de5b9..44fc19f1f6 100644 --- a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeatureAllOf.ts +++ b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOuterObjectFeatureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOwnFeature.ts b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOwnFeature.ts index 77793afdf4..abf04eae31 100644 --- a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOwnFeature.ts +++ b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOwnFeature.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOwnFeatureAllOf.ts b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOwnFeatureAllOf.ts index b9e0755d9b..0707904db6 100644 --- a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOwnFeatureAllOf.ts +++ b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionIfOwnFeatureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionType.ts b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionType.ts index 20f5428c6e..f1ba620bed 100644 --- a/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionType.ts +++ b/sdk/typescript/lib/generated/models/FieldSchemaFeatureConditionType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSubstateKey.ts b/sdk/typescript/lib/generated/models/FieldSubstateKey.ts index 6d10877d92..98956f64e0 100644 --- a/sdk/typescript/lib/generated/models/FieldSubstateKey.ts +++ b/sdk/typescript/lib/generated/models/FieldSubstateKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FieldSubstateKeyAllOf.ts b/sdk/typescript/lib/generated/models/FieldSubstateKeyAllOf.ts index d78a7edf0f..056f9cd452 100644 --- a/sdk/typescript/lib/generated/models/FieldSubstateKeyAllOf.ts +++ b/sdk/typescript/lib/generated/models/FieldSubstateKeyAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FlashLedgerTransaction.ts b/sdk/typescript/lib/generated/models/FlashLedgerTransaction.ts index a5cc85bce3..ff1977bda8 100644 --- a/sdk/typescript/lib/generated/models/FlashLedgerTransaction.ts +++ b/sdk/typescript/lib/generated/models/FlashLedgerTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FlashLedgerTransactionAllOf.ts b/sdk/typescript/lib/generated/models/FlashLedgerTransactionAllOf.ts index 34c4094358..fda0efee3e 100644 --- a/sdk/typescript/lib/generated/models/FlashLedgerTransactionAllOf.ts +++ b/sdk/typescript/lib/generated/models/FlashLedgerTransactionAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FlashSetSubstate.ts b/sdk/typescript/lib/generated/models/FlashSetSubstate.ts index f0fdf1cc3d..6987f30449 100644 --- a/sdk/typescript/lib/generated/models/FlashSetSubstate.ts +++ b/sdk/typescript/lib/generated/models/FlashSetSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FlashedStateUpdates.ts b/sdk/typescript/lib/generated/models/FlashedStateUpdates.ts index 025a794c68..0a39331feb 100644 --- a/sdk/typescript/lib/generated/models/FlashedStateUpdates.ts +++ b/sdk/typescript/lib/generated/models/FlashedStateUpdates.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FrozenStatus.ts b/sdk/typescript/lib/generated/models/FrozenStatus.ts index 7599d66323..2e63188ca6 100644 --- a/sdk/typescript/lib/generated/models/FrozenStatus.ts +++ b/sdk/typescript/lib/generated/models/FrozenStatus.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FullyScopedTypeId.ts b/sdk/typescript/lib/generated/models/FullyScopedTypeId.ts index 9d32e28f3f..5f44dd8b4c 100644 --- a/sdk/typescript/lib/generated/models/FullyScopedTypeId.ts +++ b/sdk/typescript/lib/generated/models/FullyScopedTypeId.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FunctionAuthType.ts b/sdk/typescript/lib/generated/models/FunctionAuthType.ts index 2882388b25..855988ee7c 100644 --- a/sdk/typescript/lib/generated/models/FunctionAuthType.ts +++ b/sdk/typescript/lib/generated/models/FunctionAuthType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FunctionEventEmitterIdentifier.ts b/sdk/typescript/lib/generated/models/FunctionEventEmitterIdentifier.ts index 1ec792efe8..b095ab0a6e 100644 --- a/sdk/typescript/lib/generated/models/FunctionEventEmitterIdentifier.ts +++ b/sdk/typescript/lib/generated/models/FunctionEventEmitterIdentifier.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FunctionEventEmitterIdentifierAllOf.ts b/sdk/typescript/lib/generated/models/FunctionEventEmitterIdentifierAllOf.ts index ed6c5959fa..2aa2d97f11 100644 --- a/sdk/typescript/lib/generated/models/FunctionEventEmitterIdentifierAllOf.ts +++ b/sdk/typescript/lib/generated/models/FunctionEventEmitterIdentifierAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FunctionSchema.ts b/sdk/typescript/lib/generated/models/FunctionSchema.ts index f1340667ad..f043f75d9b 100644 --- a/sdk/typescript/lib/generated/models/FunctionSchema.ts +++ b/sdk/typescript/lib/generated/models/FunctionSchema.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleResourceAmount.ts b/sdk/typescript/lib/generated/models/FungibleResourceAmount.ts index a50cc67b96..23156108c5 100644 --- a/sdk/typescript/lib/generated/models/FungibleResourceAmount.ts +++ b/sdk/typescript/lib/generated/models/FungibleResourceAmount.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleResourceAmountAllOf.ts b/sdk/typescript/lib/generated/models/FungibleResourceAmountAllOf.ts index 18c0246766..4febf02127 100644 --- a/sdk/typescript/lib/generated/models/FungibleResourceAmountAllOf.ts +++ b/sdk/typescript/lib/generated/models/FungibleResourceAmountAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilitySubstate.ts b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilitySubstate.ts index 852d4af892..b6e4800177 100644 --- a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilitySubstate.ts +++ b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilitySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilitySubstateAllOf.ts b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilitySubstateAllOf.ts index 5affa613e7..6ce4d4d1a8 100644 --- a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilitySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilitySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilityValue.ts b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilityValue.ts index 2e424dfff3..b36d14bbff 100644 --- a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilityValue.ts +++ b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldDivisibilityValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplySubstate.ts b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplySubstate.ts index e1e7643c95..85c864a039 100644 --- a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplySubstate.ts +++ b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplySubstateAllOf.ts b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplySubstateAllOf.ts index 0342bd118e..e10147c277 100644 --- a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplyValue.ts b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplyValue.ts index 0d7e4c2aaa..6b9fd7da42 100644 --- a/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplyValue.ts +++ b/sdk/typescript/lib/generated/models/FungibleResourceManagerFieldTotalSupplyValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceSubstate.ts b/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceSubstate.ts index 5dbe83cfae..5d89497206 100644 --- a/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceSubstate.ts +++ b/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceSubstateAllOf.ts b/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceSubstateAllOf.ts index dbbdf441f0..892a3403b2 100644 --- a/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceValue.ts b/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceValue.ts index 2aae99c684..ac229a8696 100644 --- a/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceValue.ts +++ b/sdk/typescript/lib/generated/models/FungibleVaultFieldBalanceValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusSubstate.ts b/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusSubstate.ts index 7281880ef9..5cae0e44c3 100644 --- a/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusSubstate.ts +++ b/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusSubstateAllOf.ts b/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusSubstateAllOf.ts index 9c96acd329..11772df30d 100644 --- a/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusValue.ts b/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusValue.ts index 56a004e5a5..c8fc897d2c 100644 --- a/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusValue.ts +++ b/sdk/typescript/lib/generated/models/FungibleVaultFieldFrozenStatusValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericBlueprintPayloadDef.ts b/sdk/typescript/lib/generated/models/GenericBlueprintPayloadDef.ts index 5345fe5da3..81017f7b5c 100644 --- a/sdk/typescript/lib/generated/models/GenericBlueprintPayloadDef.ts +++ b/sdk/typescript/lib/generated/models/GenericBlueprintPayloadDef.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericBlueprintPayloadDefAllOf.ts b/sdk/typescript/lib/generated/models/GenericBlueprintPayloadDefAllOf.ts index d7940ee921..4c48de8eb9 100644 --- a/sdk/typescript/lib/generated/models/GenericBlueprintPayloadDefAllOf.ts +++ b/sdk/typescript/lib/generated/models/GenericBlueprintPayloadDefAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericKey.ts b/sdk/typescript/lib/generated/models/GenericKey.ts index 803048e061..663aaf4bac 100644 --- a/sdk/typescript/lib/generated/models/GenericKey.ts +++ b/sdk/typescript/lib/generated/models/GenericKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntrySubstate.ts b/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntrySubstate.ts index a8b6a45138..fccbe06353 100644 --- a/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntrySubstateAllOf.ts index 955e0fc997..67b60be1e0 100644 --- a/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntryValue.ts b/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntryValue.ts index 801fae0588..9008fbd9c7 100644 --- a/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntryValue.ts +++ b/sdk/typescript/lib/generated/models/GenericKeyValueStoreEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateSubstate.ts index 0ff5f5afb4..4954e24719 100644 --- a/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateSubstateAllOf.ts index 673490c84e..de8e8bcc99 100644 --- a/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateValue.ts b/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateValue.ts index 248f24516d..38476226eb 100644 --- a/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/GenericScryptoComponentFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericSubstitution.ts b/sdk/typescript/lib/generated/models/GenericSubstitution.ts index 115a2738fe..07090d5891 100644 --- a/sdk/typescript/lib/generated/models/GenericSubstitution.ts +++ b/sdk/typescript/lib/generated/models/GenericSubstitution.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericSubstitutionBase.ts b/sdk/typescript/lib/generated/models/GenericSubstitutionBase.ts index c207b6aa68..2a7f426845 100644 --- a/sdk/typescript/lib/generated/models/GenericSubstitutionBase.ts +++ b/sdk/typescript/lib/generated/models/GenericSubstitutionBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericSubstitutionType.ts b/sdk/typescript/lib/generated/models/GenericSubstitutionType.ts index b90a8b0c7e..d13fe946ba 100644 --- a/sdk/typescript/lib/generated/models/GenericSubstitutionType.ts +++ b/sdk/typescript/lib/generated/models/GenericSubstitutionType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericTypeParameter.ts b/sdk/typescript/lib/generated/models/GenericTypeParameter.ts index 91eb5b142e..e55c3dcf5f 100644 --- a/sdk/typescript/lib/generated/models/GenericTypeParameter.ts +++ b/sdk/typescript/lib/generated/models/GenericTypeParameter.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenericTypeParameterConstraints.ts b/sdk/typescript/lib/generated/models/GenericTypeParameterConstraints.ts index b3a148dc77..0a5d25227c 100644 --- a/sdk/typescript/lib/generated/models/GenericTypeParameterConstraints.ts +++ b/sdk/typescript/lib/generated/models/GenericTypeParameterConstraints.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenesisLedgerProofOrigin.ts b/sdk/typescript/lib/generated/models/GenesisLedgerProofOrigin.ts index 9ee5484c4c..b59d6a19ac 100644 --- a/sdk/typescript/lib/generated/models/GenesisLedgerProofOrigin.ts +++ b/sdk/typescript/lib/generated/models/GenesisLedgerProofOrigin.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenesisLedgerProofOriginAllOf.ts b/sdk/typescript/lib/generated/models/GenesisLedgerProofOriginAllOf.ts index dd989c7642..9f49b078a9 100644 --- a/sdk/typescript/lib/generated/models/GenesisLedgerProofOriginAllOf.ts +++ b/sdk/typescript/lib/generated/models/GenesisLedgerProofOriginAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenesisLedgerTransaction.ts b/sdk/typescript/lib/generated/models/GenesisLedgerTransaction.ts index 6071c1cd2d..a05790b41f 100644 --- a/sdk/typescript/lib/generated/models/GenesisLedgerTransaction.ts +++ b/sdk/typescript/lib/generated/models/GenesisLedgerTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/GenesisLedgerTransactionAllOf.ts b/sdk/typescript/lib/generated/models/GenesisLedgerTransactionAllOf.ts index ef4cf069ca..fa38a617f7 100644 --- a/sdk/typescript/lib/generated/models/GenesisLedgerTransactionAllOf.ts +++ b/sdk/typescript/lib/generated/models/GenesisLedgerTransactionAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/HookExport.ts b/sdk/typescript/lib/generated/models/HookExport.ts index 68bdc2072b..fe8879c560 100644 --- a/sdk/typescript/lib/generated/models/HookExport.ts +++ b/sdk/typescript/lib/generated/models/HookExport.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/IndexBlueprintCollectionSchema.ts b/sdk/typescript/lib/generated/models/IndexBlueprintCollectionSchema.ts index 2164d0dac6..aae9e621bc 100644 --- a/sdk/typescript/lib/generated/models/IndexBlueprintCollectionSchema.ts +++ b/sdk/typescript/lib/generated/models/IndexBlueprintCollectionSchema.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/IndexBlueprintCollectionSchemaAllOf.ts b/sdk/typescript/lib/generated/models/IndexBlueprintCollectionSchemaAllOf.ts index 9a82bd9e36..e92765f132 100644 --- a/sdk/typescript/lib/generated/models/IndexBlueprintCollectionSchemaAllOf.ts +++ b/sdk/typescript/lib/generated/models/IndexBlueprintCollectionSchemaAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/IndexedStateSchema.ts b/sdk/typescript/lib/generated/models/IndexedStateSchema.ts index 2270028333..2ed37b8a23 100644 --- a/sdk/typescript/lib/generated/models/IndexedStateSchema.ts +++ b/sdk/typescript/lib/generated/models/IndexedStateSchema.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/InstanceSchemaBlueprintTypeReference.ts b/sdk/typescript/lib/generated/models/InstanceSchemaBlueprintTypeReference.ts index 4936fafb45..aa48bef941 100644 --- a/sdk/typescript/lib/generated/models/InstanceSchemaBlueprintTypeReference.ts +++ b/sdk/typescript/lib/generated/models/InstanceSchemaBlueprintTypeReference.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/InstanceSchemaBlueprintTypeReferenceAllOf.ts b/sdk/typescript/lib/generated/models/InstanceSchemaBlueprintTypeReferenceAllOf.ts index 50369bd294..2e301edaf5 100644 --- a/sdk/typescript/lib/generated/models/InstanceSchemaBlueprintTypeReferenceAllOf.ts +++ b/sdk/typescript/lib/generated/models/InstanceSchemaBlueprintTypeReferenceAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/Instant.ts b/sdk/typescript/lib/generated/models/Instant.ts index c580ef19df..c0a6bb17b9 100644 --- a/sdk/typescript/lib/generated/models/Instant.ts +++ b/sdk/typescript/lib/generated/models/Instant.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/InstructionResourceChanges.ts b/sdk/typescript/lib/generated/models/InstructionResourceChanges.ts index 2de6736d08..34486c8da8 100644 --- a/sdk/typescript/lib/generated/models/InstructionResourceChanges.ts +++ b/sdk/typescript/lib/generated/models/InstructionResourceChanges.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/KeyValueBasedStructure.ts b/sdk/typescript/lib/generated/models/KeyValueBasedStructure.ts index 55f5ebdc4d..a187937dca 100644 --- a/sdk/typescript/lib/generated/models/KeyValueBasedStructure.ts +++ b/sdk/typescript/lib/generated/models/KeyValueBasedStructure.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/KeyValueBlueprintCollectionSchema.ts b/sdk/typescript/lib/generated/models/KeyValueBlueprintCollectionSchema.ts index 369b8c8ecd..eac707eb87 100644 --- a/sdk/typescript/lib/generated/models/KeyValueBlueprintCollectionSchema.ts +++ b/sdk/typescript/lib/generated/models/KeyValueBlueprintCollectionSchema.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/KeyValueBlueprintCollectionSchemaAllOf.ts b/sdk/typescript/lib/generated/models/KeyValueBlueprintCollectionSchemaAllOf.ts index 2653f93058..a2c5b15eb8 100644 --- a/sdk/typescript/lib/generated/models/KeyValueBlueprintCollectionSchemaAllOf.ts +++ b/sdk/typescript/lib/generated/models/KeyValueBlueprintCollectionSchemaAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/KeyValueStoreEntryStructure.ts b/sdk/typescript/lib/generated/models/KeyValueStoreEntryStructure.ts index f7405dabe8..052233c289 100644 --- a/sdk/typescript/lib/generated/models/KeyValueStoreEntryStructure.ts +++ b/sdk/typescript/lib/generated/models/KeyValueStoreEntryStructure.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/KeyValueStoreEntryStructureAllOf.ts b/sdk/typescript/lib/generated/models/KeyValueStoreEntryStructureAllOf.ts index c7ee33946e..5837d5420f 100644 --- a/sdk/typescript/lib/generated/models/KeyValueStoreEntryStructureAllOf.ts +++ b/sdk/typescript/lib/generated/models/KeyValueStoreEntryStructureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/KeyValueStoreInfo.ts b/sdk/typescript/lib/generated/models/KeyValueStoreInfo.ts index b58c998552..1f7288dd0d 100644 --- a/sdk/typescript/lib/generated/models/KeyValueStoreInfo.ts +++ b/sdk/typescript/lib/generated/models/KeyValueStoreInfo.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/KeyValueStoreTypeInfoDetails.ts b/sdk/typescript/lib/generated/models/KeyValueStoreTypeInfoDetails.ts index abed1ee923..4271b48bfa 100644 --- a/sdk/typescript/lib/generated/models/KeyValueStoreTypeInfoDetails.ts +++ b/sdk/typescript/lib/generated/models/KeyValueStoreTypeInfoDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/KeyValueStoreTypeInfoDetailsAllOf.ts b/sdk/typescript/lib/generated/models/KeyValueStoreTypeInfoDetailsAllOf.ts index 51701e9939..42e8758b0d 100644 --- a/sdk/typescript/lib/generated/models/KeyValueStoreTypeInfoDetailsAllOf.ts +++ b/sdk/typescript/lib/generated/models/KeyValueStoreTypeInfoDetailsAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LeaderProposalHistory.ts b/sdk/typescript/lib/generated/models/LeaderProposalHistory.ts index 4970ff3e81..61e4c1d81e 100644 --- a/sdk/typescript/lib/generated/models/LeaderProposalHistory.ts +++ b/sdk/typescript/lib/generated/models/LeaderProposalHistory.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerHashes.ts b/sdk/typescript/lib/generated/models/LedgerHashes.ts index 5acf24a2b1..334cbcd85c 100644 --- a/sdk/typescript/lib/generated/models/LedgerHashes.ts +++ b/sdk/typescript/lib/generated/models/LedgerHashes.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerHeader.ts b/sdk/typescript/lib/generated/models/LedgerHeader.ts index b7ba47242d..74d717a95e 100644 --- a/sdk/typescript/lib/generated/models/LedgerHeader.ts +++ b/sdk/typescript/lib/generated/models/LedgerHeader.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerHeaderSummary.ts b/sdk/typescript/lib/generated/models/LedgerHeaderSummary.ts index 5ce395d178..b52d207408 100644 --- a/sdk/typescript/lib/generated/models/LedgerHeaderSummary.ts +++ b/sdk/typescript/lib/generated/models/LedgerHeaderSummary.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerProof.ts b/sdk/typescript/lib/generated/models/LedgerProof.ts index 97cedfefd9..67f41a1f0c 100644 --- a/sdk/typescript/lib/generated/models/LedgerProof.ts +++ b/sdk/typescript/lib/generated/models/LedgerProof.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerProofOrigin.ts b/sdk/typescript/lib/generated/models/LedgerProofOrigin.ts index 7837b1dc46..24330a4674 100644 --- a/sdk/typescript/lib/generated/models/LedgerProofOrigin.ts +++ b/sdk/typescript/lib/generated/models/LedgerProofOrigin.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerProofOriginBase.ts b/sdk/typescript/lib/generated/models/LedgerProofOriginBase.ts index f4b5ab11ab..9fae769dbc 100644 --- a/sdk/typescript/lib/generated/models/LedgerProofOriginBase.ts +++ b/sdk/typescript/lib/generated/models/LedgerProofOriginBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerProofOriginType.ts b/sdk/typescript/lib/generated/models/LedgerProofOriginType.ts index 455c59ac9a..e949db017a 100644 --- a/sdk/typescript/lib/generated/models/LedgerProofOriginType.ts +++ b/sdk/typescript/lib/generated/models/LedgerProofOriginType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerStateSummary.ts b/sdk/typescript/lib/generated/models/LedgerStateSummary.ts index 2665007929..d2b0f9a74c 100644 --- a/sdk/typescript/lib/generated/models/LedgerStateSummary.ts +++ b/sdk/typescript/lib/generated/models/LedgerStateSummary.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerTransaction.ts b/sdk/typescript/lib/generated/models/LedgerTransaction.ts index 65c7bab67a..27c0783a08 100644 --- a/sdk/typescript/lib/generated/models/LedgerTransaction.ts +++ b/sdk/typescript/lib/generated/models/LedgerTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerTransactionBase.ts b/sdk/typescript/lib/generated/models/LedgerTransactionBase.ts index e4087147e3..41a3758923 100644 --- a/sdk/typescript/lib/generated/models/LedgerTransactionBase.ts +++ b/sdk/typescript/lib/generated/models/LedgerTransactionBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LedgerTransactionType.ts b/sdk/typescript/lib/generated/models/LedgerTransactionType.ts index 18bb22fd45..5847f2eb46 100644 --- a/sdk/typescript/lib/generated/models/LedgerTransactionType.ts +++ b/sdk/typescript/lib/generated/models/LedgerTransactionType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LocalGenericSubstitution.ts b/sdk/typescript/lib/generated/models/LocalGenericSubstitution.ts index aab1fd768a..e7a65c261e 100644 --- a/sdk/typescript/lib/generated/models/LocalGenericSubstitution.ts +++ b/sdk/typescript/lib/generated/models/LocalGenericSubstitution.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LocalGenericSubstitutionAllOf.ts b/sdk/typescript/lib/generated/models/LocalGenericSubstitutionAllOf.ts index a35c43a380..a8f3dec16d 100644 --- a/sdk/typescript/lib/generated/models/LocalGenericSubstitutionAllOf.ts +++ b/sdk/typescript/lib/generated/models/LocalGenericSubstitutionAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LocalNonFungibleKey.ts b/sdk/typescript/lib/generated/models/LocalNonFungibleKey.ts index 6fab72b572..7b03d9fe9f 100644 --- a/sdk/typescript/lib/generated/models/LocalNonFungibleKey.ts +++ b/sdk/typescript/lib/generated/models/LocalNonFungibleKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LocalTypeId.ts b/sdk/typescript/lib/generated/models/LocalTypeId.ts index 578a020afb..295c795bc7 100644 --- a/sdk/typescript/lib/generated/models/LocalTypeId.ts +++ b/sdk/typescript/lib/generated/models/LocalTypeId.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsCommittedTransactionOutcome.ts b/sdk/typescript/lib/generated/models/LtsCommittedTransactionOutcome.ts index f034f6de20..5dbddbe88f 100644 --- a/sdk/typescript/lib/generated/models/LtsCommittedTransactionOutcome.ts +++ b/sdk/typescript/lib/generated/models/LtsCommittedTransactionOutcome.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsCommittedTransactionStatus.ts b/sdk/typescript/lib/generated/models/LtsCommittedTransactionStatus.ts index eed9391588..218a9cb371 100644 --- a/sdk/typescript/lib/generated/models/LtsCommittedTransactionStatus.ts +++ b/sdk/typescript/lib/generated/models/LtsCommittedTransactionStatus.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsEntityFungibleBalanceChanges.ts b/sdk/typescript/lib/generated/models/LtsEntityFungibleBalanceChanges.ts index 7525d9f0e4..f61fd869f0 100644 --- a/sdk/typescript/lib/generated/models/LtsEntityFungibleBalanceChanges.ts +++ b/sdk/typescript/lib/generated/models/LtsEntityFungibleBalanceChanges.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsEntityNonFungibleBalanceChanges.ts b/sdk/typescript/lib/generated/models/LtsEntityNonFungibleBalanceChanges.ts index ab96ea0101..f6b8f40f64 100644 --- a/sdk/typescript/lib/generated/models/LtsEntityNonFungibleBalanceChanges.ts +++ b/sdk/typescript/lib/generated/models/LtsEntityNonFungibleBalanceChanges.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsFeeFungibleResourceBalanceChange.ts b/sdk/typescript/lib/generated/models/LtsFeeFungibleResourceBalanceChange.ts index 815dfc9bde..7c8806fb33 100644 --- a/sdk/typescript/lib/generated/models/LtsFeeFungibleResourceBalanceChange.ts +++ b/sdk/typescript/lib/generated/models/LtsFeeFungibleResourceBalanceChange.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsFeeFungibleResourceBalanceChangeType.ts b/sdk/typescript/lib/generated/models/LtsFeeFungibleResourceBalanceChangeType.ts index bc592c4de0..4ce0cb6ae0 100644 --- a/sdk/typescript/lib/generated/models/LtsFeeFungibleResourceBalanceChangeType.ts +++ b/sdk/typescript/lib/generated/models/LtsFeeFungibleResourceBalanceChangeType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsFungibleResourceBalance.ts b/sdk/typescript/lib/generated/models/LtsFungibleResourceBalance.ts index b96d3ec760..072a4839da 100644 --- a/sdk/typescript/lib/generated/models/LtsFungibleResourceBalance.ts +++ b/sdk/typescript/lib/generated/models/LtsFungibleResourceBalance.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsFungibleResourceBalanceChange.ts b/sdk/typescript/lib/generated/models/LtsFungibleResourceBalanceChange.ts index 71ea073f9c..f3e768734b 100644 --- a/sdk/typescript/lib/generated/models/LtsFungibleResourceBalanceChange.ts +++ b/sdk/typescript/lib/generated/models/LtsFungibleResourceBalanceChange.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsResultantAccountFungibleBalances.ts b/sdk/typescript/lib/generated/models/LtsResultantAccountFungibleBalances.ts index 8af9c31a0c..1daa826510 100644 --- a/sdk/typescript/lib/generated/models/LtsResultantAccountFungibleBalances.ts +++ b/sdk/typescript/lib/generated/models/LtsResultantAccountFungibleBalances.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsResultantFungibleBalance.ts b/sdk/typescript/lib/generated/models/LtsResultantFungibleBalance.ts index 90ce970c33..e54a3de8a6 100644 --- a/sdk/typescript/lib/generated/models/LtsResultantFungibleBalance.ts +++ b/sdk/typescript/lib/generated/models/LtsResultantFungibleBalance.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStateAccountAllFungibleResourceBalancesRequest.ts b/sdk/typescript/lib/generated/models/LtsStateAccountAllFungibleResourceBalancesRequest.ts index 8477a1f01b..ae7f6ad3f3 100644 --- a/sdk/typescript/lib/generated/models/LtsStateAccountAllFungibleResourceBalancesRequest.ts +++ b/sdk/typescript/lib/generated/models/LtsStateAccountAllFungibleResourceBalancesRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStateAccountAllFungibleResourceBalancesResponse.ts b/sdk/typescript/lib/generated/models/LtsStateAccountAllFungibleResourceBalancesResponse.ts index 499d4b792f..fa61a2ea48 100644 --- a/sdk/typescript/lib/generated/models/LtsStateAccountAllFungibleResourceBalancesResponse.ts +++ b/sdk/typescript/lib/generated/models/LtsStateAccountAllFungibleResourceBalancesResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStateAccountDepositBehaviourRequest.ts b/sdk/typescript/lib/generated/models/LtsStateAccountDepositBehaviourRequest.ts index ec3a0a9def..9d4e4270c7 100644 --- a/sdk/typescript/lib/generated/models/LtsStateAccountDepositBehaviourRequest.ts +++ b/sdk/typescript/lib/generated/models/LtsStateAccountDepositBehaviourRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStateAccountDepositBehaviourResponse.ts b/sdk/typescript/lib/generated/models/LtsStateAccountDepositBehaviourResponse.ts index 61364324e4..fcfd844020 100644 --- a/sdk/typescript/lib/generated/models/LtsStateAccountDepositBehaviourResponse.ts +++ b/sdk/typescript/lib/generated/models/LtsStateAccountDepositBehaviourResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStateAccountFungibleResourceBalanceRequest.ts b/sdk/typescript/lib/generated/models/LtsStateAccountFungibleResourceBalanceRequest.ts index 563406c14a..dcc82b6898 100644 --- a/sdk/typescript/lib/generated/models/LtsStateAccountFungibleResourceBalanceRequest.ts +++ b/sdk/typescript/lib/generated/models/LtsStateAccountFungibleResourceBalanceRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStateAccountFungibleResourceBalanceResponse.ts b/sdk/typescript/lib/generated/models/LtsStateAccountFungibleResourceBalanceResponse.ts index b127fc48ca..22074b80f2 100644 --- a/sdk/typescript/lib/generated/models/LtsStateAccountFungibleResourceBalanceResponse.ts +++ b/sdk/typescript/lib/generated/models/LtsStateAccountFungibleResourceBalanceResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStreamAccountTransactionOutcomesRequest.ts b/sdk/typescript/lib/generated/models/LtsStreamAccountTransactionOutcomesRequest.ts index d42884c2db..2cb7c6caa2 100644 --- a/sdk/typescript/lib/generated/models/LtsStreamAccountTransactionOutcomesRequest.ts +++ b/sdk/typescript/lib/generated/models/LtsStreamAccountTransactionOutcomesRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStreamAccountTransactionOutcomesResponse.ts b/sdk/typescript/lib/generated/models/LtsStreamAccountTransactionOutcomesResponse.ts index 185660a63f..93e7a091e9 100644 --- a/sdk/typescript/lib/generated/models/LtsStreamAccountTransactionOutcomesResponse.ts +++ b/sdk/typescript/lib/generated/models/LtsStreamAccountTransactionOutcomesResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStreamTransactionOutcomesRequest.ts b/sdk/typescript/lib/generated/models/LtsStreamTransactionOutcomesRequest.ts index fe93bb89bb..834358d114 100644 --- a/sdk/typescript/lib/generated/models/LtsStreamTransactionOutcomesRequest.ts +++ b/sdk/typescript/lib/generated/models/LtsStreamTransactionOutcomesRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsStreamTransactionOutcomesResponse.ts b/sdk/typescript/lib/generated/models/LtsStreamTransactionOutcomesResponse.ts index 9d45b52a6a..a6c1caf96b 100644 --- a/sdk/typescript/lib/generated/models/LtsStreamTransactionOutcomesResponse.ts +++ b/sdk/typescript/lib/generated/models/LtsStreamTransactionOutcomesResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionConstructionRequest.ts b/sdk/typescript/lib/generated/models/LtsTransactionConstructionRequest.ts index 680f61929d..036fb9e6fb 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionConstructionRequest.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionConstructionRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionConstructionResponse.ts b/sdk/typescript/lib/generated/models/LtsTransactionConstructionResponse.ts index e8525068ee..0681f5a047 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionConstructionResponse.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionConstructionResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionIntentStatus.ts b/sdk/typescript/lib/generated/models/LtsTransactionIntentStatus.ts index bfc864c717..2920bc0631 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionIntentStatus.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionIntentStatus.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionPayloadDetails.ts b/sdk/typescript/lib/generated/models/LtsTransactionPayloadDetails.ts index 27f3b7aa0e..b7988a0042 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionPayloadDetails.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionPayloadDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionPayloadStatus.ts b/sdk/typescript/lib/generated/models/LtsTransactionPayloadStatus.ts index 2a8de82919..4dd80d7005 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionPayloadStatus.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionPayloadStatus.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionStatusRequest.ts b/sdk/typescript/lib/generated/models/LtsTransactionStatusRequest.ts index 4b183d8085..a0519dda07 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionStatusRequest.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionStatusRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionStatusResponse.ts b/sdk/typescript/lib/generated/models/LtsTransactionStatusResponse.ts index b5b029571e..6865447dd4 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionStatusResponse.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionStatusResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetails.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetails.ts index b93c74b430..077d0fda47 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetails.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetailsBase.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetailsBase.ts index 8ebc25c455..bacbc656c5 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetailsBase.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetailsBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetailsType.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetailsType.ts index be75d44a24..deff389b27 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetailsType.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorDetailsType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorResponse.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorResponse.ts index 9bb3e807a6..ed9a5ac75b 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorResponse.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorResponseAllOf.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorResponseAllOf.ts index 2ff05fb736..6f5bcf6e87 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorResponseAllOf.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitErrorResponseAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitIntentAlreadyCommitted.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitIntentAlreadyCommitted.ts index dc829a9d17..90b595369d 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitIntentAlreadyCommitted.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitIntentAlreadyCommitted.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitIntentAlreadyCommittedAllOf.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitIntentAlreadyCommittedAllOf.ts index 7dc93787a5..a2fe4d4e88 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitIntentAlreadyCommittedAllOf.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitIntentAlreadyCommittedAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetails.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetails.ts index f7e8ceef27..cbc2a5cca0 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetails.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetailsAllOf.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetailsAllOf.ts index 6d39b95dc1..6aa2337f96 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetailsAllOf.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitPriorityThresholdNotMetErrorDetailsAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitRejectedErrorDetails.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitRejectedErrorDetails.ts index 630886f2fe..9a956477dd 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitRejectedErrorDetails.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitRejectedErrorDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitRejectedErrorDetailsAllOf.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitRejectedErrorDetailsAllOf.ts index 5565b8871c..9f47dc65cd 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitRejectedErrorDetailsAllOf.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitRejectedErrorDetailsAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitRequest.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitRequest.ts index e4188f0720..1137bd5787 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitRequest.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/LtsTransactionSubmitResponse.ts b/sdk/typescript/lib/generated/models/LtsTransactionSubmitResponse.ts index 08f72a6231..7f81575deb 100644 --- a/sdk/typescript/lib/generated/models/LtsTransactionSubmitResponse.ts +++ b/sdk/typescript/lib/generated/models/LtsTransactionSubmitResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MainMethodKey.ts b/sdk/typescript/lib/generated/models/MainMethodKey.ts index a892f13b78..d2ea918035 100644 --- a/sdk/typescript/lib/generated/models/MainMethodKey.ts +++ b/sdk/typescript/lib/generated/models/MainMethodKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MapSubstateKey.ts b/sdk/typescript/lib/generated/models/MapSubstateKey.ts index fe25c0f07b..91a092b0c9 100644 --- a/sdk/typescript/lib/generated/models/MapSubstateKey.ts +++ b/sdk/typescript/lib/generated/models/MapSubstateKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MapSubstateKeyAllOf.ts b/sdk/typescript/lib/generated/models/MapSubstateKeyAllOf.ts index b1f5ad7346..bd56cf2265 100644 --- a/sdk/typescript/lib/generated/models/MapSubstateKeyAllOf.ts +++ b/sdk/typescript/lib/generated/models/MapSubstateKeyAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MempoolListRequest.ts b/sdk/typescript/lib/generated/models/MempoolListRequest.ts index 187ff0c914..e9417bd448 100644 --- a/sdk/typescript/lib/generated/models/MempoolListRequest.ts +++ b/sdk/typescript/lib/generated/models/MempoolListRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MempoolListResponse.ts b/sdk/typescript/lib/generated/models/MempoolListResponse.ts index 7d59fcf06b..1325a544b3 100644 --- a/sdk/typescript/lib/generated/models/MempoolListResponse.ts +++ b/sdk/typescript/lib/generated/models/MempoolListResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MempoolTransactionHashes.ts b/sdk/typescript/lib/generated/models/MempoolTransactionHashes.ts index fa3ff1aaa6..7e03cfd13c 100644 --- a/sdk/typescript/lib/generated/models/MempoolTransactionHashes.ts +++ b/sdk/typescript/lib/generated/models/MempoolTransactionHashes.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MempoolTransactionRequest.ts b/sdk/typescript/lib/generated/models/MempoolTransactionRequest.ts index 6782c874e7..657fe81e1e 100644 --- a/sdk/typescript/lib/generated/models/MempoolTransactionRequest.ts +++ b/sdk/typescript/lib/generated/models/MempoolTransactionRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MempoolTransactionResponse.ts b/sdk/typescript/lib/generated/models/MempoolTransactionResponse.ts index f90acf37ea..9005e77b41 100644 --- a/sdk/typescript/lib/generated/models/MempoolTransactionResponse.ts +++ b/sdk/typescript/lib/generated/models/MempoolTransactionResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MempoolTransactionResponsePayloadsInner.ts b/sdk/typescript/lib/generated/models/MempoolTransactionResponsePayloadsInner.ts index afae958113..1c5babcf08 100644 --- a/sdk/typescript/lib/generated/models/MempoolTransactionResponsePayloadsInner.ts +++ b/sdk/typescript/lib/generated/models/MempoolTransactionResponsePayloadsInner.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MetadataKey.ts b/sdk/typescript/lib/generated/models/MetadataKey.ts index 13983c00f7..4c016a8c94 100644 --- a/sdk/typescript/lib/generated/models/MetadataKey.ts +++ b/sdk/typescript/lib/generated/models/MetadataKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MetadataModuleEntrySubstate.ts b/sdk/typescript/lib/generated/models/MetadataModuleEntrySubstate.ts index 4c9255c41c..fa97c062d6 100644 --- a/sdk/typescript/lib/generated/models/MetadataModuleEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/MetadataModuleEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MetadataModuleEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/MetadataModuleEntrySubstateAllOf.ts index 3130436436..d62afe46d8 100644 --- a/sdk/typescript/lib/generated/models/MetadataModuleEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/MetadataModuleEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MetadataModuleEntryValue.ts b/sdk/typescript/lib/generated/models/MetadataModuleEntryValue.ts index a63ce217b7..afda1307a1 100644 --- a/sdk/typescript/lib/generated/models/MetadataModuleEntryValue.ts +++ b/sdk/typescript/lib/generated/models/MetadataModuleEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MethodAccessibility.ts b/sdk/typescript/lib/generated/models/MethodAccessibility.ts index 2de15f4636..072830327e 100644 --- a/sdk/typescript/lib/generated/models/MethodAccessibility.ts +++ b/sdk/typescript/lib/generated/models/MethodAccessibility.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MethodAccessibilityBase.ts b/sdk/typescript/lib/generated/models/MethodAccessibilityBase.ts index 44d88f4626..d1e83ed2d4 100644 --- a/sdk/typescript/lib/generated/models/MethodAccessibilityBase.ts +++ b/sdk/typescript/lib/generated/models/MethodAccessibilityBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MethodAccessibilityType.ts b/sdk/typescript/lib/generated/models/MethodAccessibilityType.ts index f0ffec95ba..a9e3fd8315 100644 --- a/sdk/typescript/lib/generated/models/MethodAccessibilityType.ts +++ b/sdk/typescript/lib/generated/models/MethodAccessibilityType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MethodAuthType.ts b/sdk/typescript/lib/generated/models/MethodAuthType.ts index 33d9bd3878..71f0d57de7 100644 --- a/sdk/typescript/lib/generated/models/MethodAuthType.ts +++ b/sdk/typescript/lib/generated/models/MethodAuthType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MethodEventEmitterIdentifier.ts b/sdk/typescript/lib/generated/models/MethodEventEmitterIdentifier.ts index 4df26d0d8a..20ec6a2a91 100644 --- a/sdk/typescript/lib/generated/models/MethodEventEmitterIdentifier.ts +++ b/sdk/typescript/lib/generated/models/MethodEventEmitterIdentifier.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MethodEventEmitterIdentifierAllOf.ts b/sdk/typescript/lib/generated/models/MethodEventEmitterIdentifierAllOf.ts index 298a92dfef..a9896a4a22 100644 --- a/sdk/typescript/lib/generated/models/MethodEventEmitterIdentifierAllOf.ts +++ b/sdk/typescript/lib/generated/models/MethodEventEmitterIdentifierAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ModuleId.ts b/sdk/typescript/lib/generated/models/ModuleId.ts index b224feb5c8..d4dd92c839 100644 --- a/sdk/typescript/lib/generated/models/ModuleId.ts +++ b/sdk/typescript/lib/generated/models/ModuleId.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ModuleVersion.ts b/sdk/typescript/lib/generated/models/ModuleVersion.ts index 4e0ac335d1..d6bde39f5e 100644 --- a/sdk/typescript/lib/generated/models/ModuleVersion.ts +++ b/sdk/typescript/lib/generated/models/ModuleVersion.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateSubstate.ts index 3096dcad86..d04b999752 100644 --- a/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateSubstateAllOf.ts index a1be3cd135..4d1f08aefa 100644 --- a/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateValue.ts b/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateValue.ts index 48b853417d..7f48aad457 100644 --- a/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/MultiResourcePoolFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/MutableField.ts b/sdk/typescript/lib/generated/models/MutableField.ts index ce2c42dca1..693e47038f 100644 --- a/sdk/typescript/lib/generated/models/MutableField.ts +++ b/sdk/typescript/lib/generated/models/MutableField.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NetworkConfigurationResponse.ts b/sdk/typescript/lib/generated/models/NetworkConfigurationResponse.ts index bc3694e557..fa61a49ce2 100644 --- a/sdk/typescript/lib/generated/models/NetworkConfigurationResponse.ts +++ b/sdk/typescript/lib/generated/models/NetworkConfigurationResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NetworkConfigurationResponseVersion.ts b/sdk/typescript/lib/generated/models/NetworkConfigurationResponseVersion.ts index 91e4d990a0..7dbe6e59e9 100644 --- a/sdk/typescript/lib/generated/models/NetworkConfigurationResponseVersion.ts +++ b/sdk/typescript/lib/generated/models/NetworkConfigurationResponseVersion.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NetworkConfigurationResponseWellKnownAddresses.ts b/sdk/typescript/lib/generated/models/NetworkConfigurationResponseWellKnownAddresses.ts index 6db19bab56..5f7d5ad59f 100644 --- a/sdk/typescript/lib/generated/models/NetworkConfigurationResponseWellKnownAddresses.ts +++ b/sdk/typescript/lib/generated/models/NetworkConfigurationResponseWellKnownAddresses.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NetworkStatusRequest.ts b/sdk/typescript/lib/generated/models/NetworkStatusRequest.ts index 1256a08d0c..c48bc40c54 100644 --- a/sdk/typescript/lib/generated/models/NetworkStatusRequest.ts +++ b/sdk/typescript/lib/generated/models/NetworkStatusRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NetworkStatusResponse.ts b/sdk/typescript/lib/generated/models/NetworkStatusResponse.ts index 6eba2beca5..70569d8255 100644 --- a/sdk/typescript/lib/generated/models/NetworkStatusResponse.ts +++ b/sdk/typescript/lib/generated/models/NetworkStatusResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NextEpoch.ts b/sdk/typescript/lib/generated/models/NextEpoch.ts index ea368187e1..1f777b8748 100644 --- a/sdk/typescript/lib/generated/models/NextEpoch.ts +++ b/sdk/typescript/lib/generated/models/NextEpoch.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleAuthorizedDepositorBadge.ts b/sdk/typescript/lib/generated/models/NonFungibleAuthorizedDepositorBadge.ts index f7b96afbf6..1cb73e3afe 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleAuthorizedDepositorBadge.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleAuthorizedDepositorBadge.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleAuthorizedDepositorBadgeAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleAuthorizedDepositorBadgeAllOf.ts index c459fbb5ee..205178e83f 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleAuthorizedDepositorBadgeAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleAuthorizedDepositorBadgeAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleGlobalId.ts b/sdk/typescript/lib/generated/models/NonFungibleGlobalId.ts index 9369cbb167..e70a3da279 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleGlobalId.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleGlobalId.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleIdType.ts b/sdk/typescript/lib/generated/models/NonFungibleIdType.ts index 675082f9bd..966b84d83a 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleIdType.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleIdType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleLocalId.ts b/sdk/typescript/lib/generated/models/NonFungibleLocalId.ts index 9e2917764f..7bf338bab3 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleLocalId.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleLocalId.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungiblePresentedBadge.ts b/sdk/typescript/lib/generated/models/NonFungiblePresentedBadge.ts index 11584205e1..d512dc7896 100644 --- a/sdk/typescript/lib/generated/models/NonFungiblePresentedBadge.ts +++ b/sdk/typescript/lib/generated/models/NonFungiblePresentedBadge.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungiblePresentedBadgeAllOf.ts b/sdk/typescript/lib/generated/models/NonFungiblePresentedBadgeAllOf.ts index 51e74dbea9..efa4b9ecd4 100644 --- a/sdk/typescript/lib/generated/models/NonFungiblePresentedBadgeAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungiblePresentedBadgeAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleRequirement.ts b/sdk/typescript/lib/generated/models/NonFungibleRequirement.ts index 53e1c0e071..67faecc869 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleRequirement.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleRequirement.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleRequirementAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleRequirementAllOf.ts index 8639050bf1..a0e8e3cec9 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleRequirementAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleRequirementAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceAmount.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceAmount.ts index f8081f3151..3a6472f93c 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceAmount.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceAmount.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceAmountAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceAmountAllOf.ts index 7e1c0bf4af..da2db76888 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceAmountAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceAmountAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntrySubstate.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntrySubstate.ts index ec4dabd413..c9aa1670cb 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntrySubstateAllOf.ts index 673ab6b47c..518ec35e18 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntryValue.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntryValue.ts index c86e05063e..d1287b6bf7 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntryValue.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerDataEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeSubstate.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeSubstate.ts index 9cd2a0401f..bc9eb33dc8 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeSubstate.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeSubstateAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeSubstateAllOf.ts index a44435d996..446f02bded 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeValue.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeValue.ts index 1dfcf42a87..05d7d8447d 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeValue.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldIdTypeValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstate.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstate.ts index 2030c95af2..fdf7c5f6ba 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstate.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstateAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstateAllOf.ts index 6d698010b3..1a19a92364 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsValue.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsValue.ts index f459cab5fc..832ba27da4 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsValue.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldMutableFieldsValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstate.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstate.ts index 29baccb9ce..c2ae64fb22 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstate.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstateAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstateAllOf.ts index 3c69047d10..ba67fd95ff 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplyValue.ts b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplyValue.ts index ed5e070652..77cc9bb336 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplyValue.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleResourceManagerFieldTotalSupplyValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntrySubstate.ts b/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntrySubstate.ts index 37c2299be5..a6de3cdbe7 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntrySubstateAllOf.ts index 607bd000f8..040f713f3c 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntryValue.ts b/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntryValue.ts index f2130328c1..7383c9feec 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntryValue.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleVaultContentsIndexEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceSubstate.ts b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceSubstate.ts index 263a73da6d..492fed47cf 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceSubstate.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceSubstateAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceSubstateAllOf.ts index 601eec5c67..35348aada0 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceValue.ts b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceValue.ts index e76b344c12..b22db0379e 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceValue.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldBalanceValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusSubstate.ts b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusSubstate.ts index b79adec4a6..1523932bf8 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusSubstate.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusSubstateAllOf.ts b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusSubstateAllOf.ts index 320878a3c2..d2216cc5ec 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusValue.ts b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusValue.ts index 073140115c..0ed10bace8 100644 --- a/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusValue.ts +++ b/sdk/typescript/lib/generated/models/NonFungibleVaultFieldFrozenStatusValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/NotarizedTransaction.ts b/sdk/typescript/lib/generated/models/NotarizedTransaction.ts index 48f2e198a4..09beccfa1c 100644 --- a/sdk/typescript/lib/generated/models/NotarizedTransaction.ts +++ b/sdk/typescript/lib/generated/models/NotarizedTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectFieldStructure.ts b/sdk/typescript/lib/generated/models/ObjectFieldStructure.ts index b63ca0f592..1f37b2fafe 100644 --- a/sdk/typescript/lib/generated/models/ObjectFieldStructure.ts +++ b/sdk/typescript/lib/generated/models/ObjectFieldStructure.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectFieldStructureAllOf.ts b/sdk/typescript/lib/generated/models/ObjectFieldStructureAllOf.ts index e77cdda11b..fe38b61e62 100644 --- a/sdk/typescript/lib/generated/models/ObjectFieldStructureAllOf.ts +++ b/sdk/typescript/lib/generated/models/ObjectFieldStructureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectHook.ts b/sdk/typescript/lib/generated/models/ObjectHook.ts index 233558981b..83ac58698f 100644 --- a/sdk/typescript/lib/generated/models/ObjectHook.ts +++ b/sdk/typescript/lib/generated/models/ObjectHook.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectIndexPartitionEntryStructure.ts b/sdk/typescript/lib/generated/models/ObjectIndexPartitionEntryStructure.ts index 4a4b20b897..8fa5291382 100644 --- a/sdk/typescript/lib/generated/models/ObjectIndexPartitionEntryStructure.ts +++ b/sdk/typescript/lib/generated/models/ObjectIndexPartitionEntryStructure.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectIndexPartitionEntryStructureAllOf.ts b/sdk/typescript/lib/generated/models/ObjectIndexPartitionEntryStructureAllOf.ts index 935752ba72..2539591f57 100644 --- a/sdk/typescript/lib/generated/models/ObjectIndexPartitionEntryStructureAllOf.ts +++ b/sdk/typescript/lib/generated/models/ObjectIndexPartitionEntryStructureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectInstanceTypeReference.ts b/sdk/typescript/lib/generated/models/ObjectInstanceTypeReference.ts index a7966c9009..3b7eec0c54 100644 --- a/sdk/typescript/lib/generated/models/ObjectInstanceTypeReference.ts +++ b/sdk/typescript/lib/generated/models/ObjectInstanceTypeReference.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectInstanceTypeReferenceAllOf.ts b/sdk/typescript/lib/generated/models/ObjectInstanceTypeReferenceAllOf.ts index e706e50eb0..885f012278 100644 --- a/sdk/typescript/lib/generated/models/ObjectInstanceTypeReferenceAllOf.ts +++ b/sdk/typescript/lib/generated/models/ObjectInstanceTypeReferenceAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectKeyValuePartitionEntryStructure.ts b/sdk/typescript/lib/generated/models/ObjectKeyValuePartitionEntryStructure.ts index 0ed9560779..4c09e01c3f 100644 --- a/sdk/typescript/lib/generated/models/ObjectKeyValuePartitionEntryStructure.ts +++ b/sdk/typescript/lib/generated/models/ObjectKeyValuePartitionEntryStructure.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectKeyValuePartitionEntryStructureAllOf.ts b/sdk/typescript/lib/generated/models/ObjectKeyValuePartitionEntryStructureAllOf.ts index 9ddff49498..47423a9273 100644 --- a/sdk/typescript/lib/generated/models/ObjectKeyValuePartitionEntryStructureAllOf.ts +++ b/sdk/typescript/lib/generated/models/ObjectKeyValuePartitionEntryStructureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectRoleKey.ts b/sdk/typescript/lib/generated/models/ObjectRoleKey.ts index d15d89c60e..d804873ddc 100644 --- a/sdk/typescript/lib/generated/models/ObjectRoleKey.ts +++ b/sdk/typescript/lib/generated/models/ObjectRoleKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectSortedIndexPartitionEntryStructure.ts b/sdk/typescript/lib/generated/models/ObjectSortedIndexPartitionEntryStructure.ts index 0663406085..dc4ddd002e 100644 --- a/sdk/typescript/lib/generated/models/ObjectSortedIndexPartitionEntryStructure.ts +++ b/sdk/typescript/lib/generated/models/ObjectSortedIndexPartitionEntryStructure.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectSortedIndexPartitionEntryStructureAllOf.ts b/sdk/typescript/lib/generated/models/ObjectSortedIndexPartitionEntryStructureAllOf.ts index d5b2fddbc1..8c11cdffc7 100644 --- a/sdk/typescript/lib/generated/models/ObjectSortedIndexPartitionEntryStructureAllOf.ts +++ b/sdk/typescript/lib/generated/models/ObjectSortedIndexPartitionEntryStructureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectSubstateTypeReference.ts b/sdk/typescript/lib/generated/models/ObjectSubstateTypeReference.ts index 982a21012e..67429eaf5a 100644 --- a/sdk/typescript/lib/generated/models/ObjectSubstateTypeReference.ts +++ b/sdk/typescript/lib/generated/models/ObjectSubstateTypeReference.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectSubstateTypeReferenceBase.ts b/sdk/typescript/lib/generated/models/ObjectSubstateTypeReferenceBase.ts index d2b0f72d1e..499052fea6 100644 --- a/sdk/typescript/lib/generated/models/ObjectSubstateTypeReferenceBase.ts +++ b/sdk/typescript/lib/generated/models/ObjectSubstateTypeReferenceBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectSubstateTypeReferenceType.ts b/sdk/typescript/lib/generated/models/ObjectSubstateTypeReferenceType.ts index e93b951631..d0d7dc18d1 100644 --- a/sdk/typescript/lib/generated/models/ObjectSubstateTypeReferenceType.ts +++ b/sdk/typescript/lib/generated/models/ObjectSubstateTypeReferenceType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectTypeInfoDetails.ts b/sdk/typescript/lib/generated/models/ObjectTypeInfoDetails.ts index 39810b8c66..83e5af54e5 100644 --- a/sdk/typescript/lib/generated/models/ObjectTypeInfoDetails.ts +++ b/sdk/typescript/lib/generated/models/ObjectTypeInfoDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ObjectTypeInfoDetailsAllOf.ts b/sdk/typescript/lib/generated/models/ObjectTypeInfoDetailsAllOf.ts index e510ffb88b..026fa07e27 100644 --- a/sdk/typescript/lib/generated/models/ObjectTypeInfoDetailsAllOf.ts +++ b/sdk/typescript/lib/generated/models/ObjectTypeInfoDetailsAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateSubstate.ts index 036fff20ea..d012f22631 100644 --- a/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateSubstateAllOf.ts index d1690c118d..d1b715238e 100644 --- a/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateValue.ts b/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateValue.ts index 29900d473a..337d9ca235 100644 --- a/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/OneResourcePoolFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/OuterObjectOnlyMethodAccessibility.ts b/sdk/typescript/lib/generated/models/OuterObjectOnlyMethodAccessibility.ts index b633836a9a..e4f2698f5b 100644 --- a/sdk/typescript/lib/generated/models/OuterObjectOnlyMethodAccessibility.ts +++ b/sdk/typescript/lib/generated/models/OuterObjectOnlyMethodAccessibility.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/OuterObjectOnlyMethodAccessibilityAllOf.ts b/sdk/typescript/lib/generated/models/OuterObjectOnlyMethodAccessibilityAllOf.ts index cf64da0c7d..c46056f1a2 100644 --- a/sdk/typescript/lib/generated/models/OuterObjectOnlyMethodAccessibilityAllOf.ts +++ b/sdk/typescript/lib/generated/models/OuterObjectOnlyMethodAccessibilityAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/OwnPackageOnlyMethodAccessibility.ts b/sdk/typescript/lib/generated/models/OwnPackageOnlyMethodAccessibility.ts index ee4449602b..f3937e9c74 100644 --- a/sdk/typescript/lib/generated/models/OwnPackageOnlyMethodAccessibility.ts +++ b/sdk/typescript/lib/generated/models/OwnPackageOnlyMethodAccessibility.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/OwnPackageOnlyMethodAccessibilityAllOf.ts b/sdk/typescript/lib/generated/models/OwnPackageOnlyMethodAccessibilityAllOf.ts index 4797e98b16..d2af26e104 100644 --- a/sdk/typescript/lib/generated/models/OwnPackageOnlyMethodAccessibilityAllOf.ts +++ b/sdk/typescript/lib/generated/models/OwnPackageOnlyMethodAccessibilityAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/OwnerRole.ts b/sdk/typescript/lib/generated/models/OwnerRole.ts index fff4eec003..71003e18bd 100644 --- a/sdk/typescript/lib/generated/models/OwnerRole.ts +++ b/sdk/typescript/lib/generated/models/OwnerRole.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/OwnerRoleUpdater.ts b/sdk/typescript/lib/generated/models/OwnerRoleUpdater.ts index 47c8ae4191..12094c1d1f 100644 --- a/sdk/typescript/lib/generated/models/OwnerRoleUpdater.ts +++ b/sdk/typescript/lib/generated/models/OwnerRoleUpdater.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntrySubstate.ts b/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntrySubstate.ts index 162f2462b9..6a72a31d92 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntrySubstateAllOf.ts index 980274da46..fe622010ea 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntryValue.ts b/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntryValue.ts index 80d3bf4eb8..5575edc6cf 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntryValue.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintAuthTemplateEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntrySubstate.ts b/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntrySubstate.ts index 0fe56f8d36..a823d02a7e 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntrySubstateAllOf.ts index 87b695667c..19c35fd8cf 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntryValue.ts b/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntryValue.ts index 211deb20b0..4eaed4a0cf 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntryValue.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintDefinitionEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntrySubstate.ts b/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntrySubstate.ts index 4d9cee8c1c..9eea374433 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntrySubstateAllOf.ts index e4615bd765..a0975a64d0 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntryValue.ts b/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntryValue.ts index 0853ccdc19..4fae99447c 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntryValue.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintDependenciesEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntrySubstate.ts b/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntrySubstate.ts index 9545176001..0b517a3681 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntrySubstateAllOf.ts index 5f5cac2fed..d77fea4364 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntryValue.ts b/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntryValue.ts index 007999173f..bdb97bb435 100644 --- a/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntryValue.ts +++ b/sdk/typescript/lib/generated/models/PackageBlueprintRoyaltyEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntrySubstate.ts b/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntrySubstate.ts index 8d1186f555..e3c297eae0 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntrySubstateAllOf.ts index 2330c26ced..70092d4cd6 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntryValue.ts b/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntryValue.ts index 22ca420214..1bafb0657c 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntryValue.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeInstrumentedCodeEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeKey.ts b/sdk/typescript/lib/generated/models/PackageCodeKey.ts index 7cf15ded3e..a0f2eec73a 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeKey.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntrySubstate.ts b/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntrySubstate.ts index c098a2ab76..1b6dcb1b60 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntrySubstateAllOf.ts index d149ea0922..eda4f8e323 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntryValue.ts b/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntryValue.ts index 7462730ca7..d69fe8fd20 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntryValue.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeOriginalCodeEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntrySubstate.ts b/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntrySubstate.ts index 0db6aa6b45..dff446aa13 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntrySubstateAllOf.ts index 2b0358d905..e4b08013bd 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntryValue.ts b/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntryValue.ts index f12ff54eec..5af316fa26 100644 --- a/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntryValue.ts +++ b/sdk/typescript/lib/generated/models/PackageCodeVmTypeEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageExport.ts b/sdk/typescript/lib/generated/models/PackageExport.ts index 732448b4f1..c93859ea08 100644 --- a/sdk/typescript/lib/generated/models/PackageExport.ts +++ b/sdk/typescript/lib/generated/models/PackageExport.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorSubstate.ts b/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorSubstate.ts index ccf2e0224c..7cfc31d9b7 100644 --- a/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorSubstate.ts +++ b/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorSubstateAllOf.ts b/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorSubstateAllOf.ts index 35704ade68..5a9f3479b5 100644 --- a/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorValue.ts b/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorValue.ts index 92ef90af8a..3d53c9ece2 100644 --- a/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorValue.ts +++ b/sdk/typescript/lib/generated/models/PackageFieldRoyaltyAccumulatorValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageObjectSubstateTypeReference.ts b/sdk/typescript/lib/generated/models/PackageObjectSubstateTypeReference.ts index a22a5d64da..ff72e5f5e7 100644 --- a/sdk/typescript/lib/generated/models/PackageObjectSubstateTypeReference.ts +++ b/sdk/typescript/lib/generated/models/PackageObjectSubstateTypeReference.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageObjectSubstateTypeReferenceAllOf.ts b/sdk/typescript/lib/generated/models/PackageObjectSubstateTypeReferenceAllOf.ts index 02c966f575..c4e92b6f22 100644 --- a/sdk/typescript/lib/generated/models/PackageObjectSubstateTypeReferenceAllOf.ts +++ b/sdk/typescript/lib/generated/models/PackageObjectSubstateTypeReferenceAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PackageTypeReference.ts b/sdk/typescript/lib/generated/models/PackageTypeReference.ts index 83e17635f8..144ecb07ca 100644 --- a/sdk/typescript/lib/generated/models/PackageTypeReference.ts +++ b/sdk/typescript/lib/generated/models/PackageTypeReference.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedLedgerTransaction.ts b/sdk/typescript/lib/generated/models/ParsedLedgerTransaction.ts index 27511dc1fc..35c1639ca8 100644 --- a/sdk/typescript/lib/generated/models/ParsedLedgerTransaction.ts +++ b/sdk/typescript/lib/generated/models/ParsedLedgerTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedLedgerTransactionAllOf.ts b/sdk/typescript/lib/generated/models/ParsedLedgerTransactionAllOf.ts index 9568ed1ce4..259f555a38 100644 --- a/sdk/typescript/lib/generated/models/ParsedLedgerTransactionAllOf.ts +++ b/sdk/typescript/lib/generated/models/ParsedLedgerTransactionAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedLedgerTransactionIdentifiers.ts b/sdk/typescript/lib/generated/models/ParsedLedgerTransactionIdentifiers.ts index bd500ae41d..5b55913991 100644 --- a/sdk/typescript/lib/generated/models/ParsedLedgerTransactionIdentifiers.ts +++ b/sdk/typescript/lib/generated/models/ParsedLedgerTransactionIdentifiers.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedNotarizedTransaction.ts b/sdk/typescript/lib/generated/models/ParsedNotarizedTransaction.ts index f35321c1f0..9c8c738a87 100644 --- a/sdk/typescript/lib/generated/models/ParsedNotarizedTransaction.ts +++ b/sdk/typescript/lib/generated/models/ParsedNotarizedTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionAllOf.ts b/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionAllOf.ts index 181e108d3c..12e25a2184 100644 --- a/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionAllOf.ts +++ b/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionAllOfValidationError.ts b/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionAllOfValidationError.ts index e295193d4b..db08d7d6d4 100644 --- a/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionAllOfValidationError.ts +++ b/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionAllOfValidationError.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionIdentifiers.ts b/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionIdentifiers.ts index 3a9bd6b51c..eb4366884e 100644 --- a/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionIdentifiers.ts +++ b/sdk/typescript/lib/generated/models/ParsedNotarizedTransactionIdentifiers.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntent.ts b/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntent.ts index e5c27f8cd8..da1fec4f0f 100644 --- a/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntent.ts +++ b/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntent.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntentAllOf.ts b/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntentAllOf.ts index e7dbc00eb3..5d42478441 100644 --- a/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntentAllOf.ts +++ b/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntentAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntentIdentifiers.ts b/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntentIdentifiers.ts index 3fdc64f37a..807d7dc8b4 100644 --- a/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntentIdentifiers.ts +++ b/sdk/typescript/lib/generated/models/ParsedSignedTransactionIntentIdentifiers.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedTransaction.ts b/sdk/typescript/lib/generated/models/ParsedTransaction.ts index d9c1ac2a42..99546721df 100644 --- a/sdk/typescript/lib/generated/models/ParsedTransaction.ts +++ b/sdk/typescript/lib/generated/models/ParsedTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedTransactionBase.ts b/sdk/typescript/lib/generated/models/ParsedTransactionBase.ts index c64a1ece7f..2d025ae987 100644 --- a/sdk/typescript/lib/generated/models/ParsedTransactionBase.ts +++ b/sdk/typescript/lib/generated/models/ParsedTransactionBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedTransactionIntent.ts b/sdk/typescript/lib/generated/models/ParsedTransactionIntent.ts index 2820f2b435..617ef00924 100644 --- a/sdk/typescript/lib/generated/models/ParsedTransactionIntent.ts +++ b/sdk/typescript/lib/generated/models/ParsedTransactionIntent.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedTransactionIntentAllOf.ts b/sdk/typescript/lib/generated/models/ParsedTransactionIntentAllOf.ts index 949e76cdd3..330f7a4372 100644 --- a/sdk/typescript/lib/generated/models/ParsedTransactionIntentAllOf.ts +++ b/sdk/typescript/lib/generated/models/ParsedTransactionIntentAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedTransactionIntentIdentifiers.ts b/sdk/typescript/lib/generated/models/ParsedTransactionIntentIdentifiers.ts index 3b30d210e2..1ec82a8fb3 100644 --- a/sdk/typescript/lib/generated/models/ParsedTransactionIntentIdentifiers.ts +++ b/sdk/typescript/lib/generated/models/ParsedTransactionIntentIdentifiers.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ParsedTransactionType.ts b/sdk/typescript/lib/generated/models/ParsedTransactionType.ts index facafc3d29..41bc711cce 100644 --- a/sdk/typescript/lib/generated/models/ParsedTransactionType.ts +++ b/sdk/typescript/lib/generated/models/ParsedTransactionType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PartitionDescription.ts b/sdk/typescript/lib/generated/models/PartitionDescription.ts index d1c9b76909..454576e000 100644 --- a/sdk/typescript/lib/generated/models/PartitionDescription.ts +++ b/sdk/typescript/lib/generated/models/PartitionDescription.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PartitionDescriptionType.ts b/sdk/typescript/lib/generated/models/PartitionDescriptionType.ts index 33ce8396b5..2169fff899 100644 --- a/sdk/typescript/lib/generated/models/PartitionDescriptionType.ts +++ b/sdk/typescript/lib/generated/models/PartitionDescriptionType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PartitionId.ts b/sdk/typescript/lib/generated/models/PartitionId.ts index 4d615fc366..1c8289891b 100644 --- a/sdk/typescript/lib/generated/models/PartitionId.ts +++ b/sdk/typescript/lib/generated/models/PartitionId.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PartitionKind.ts b/sdk/typescript/lib/generated/models/PartitionKind.ts index 05a633e242..f7d8da016b 100644 --- a/sdk/typescript/lib/generated/models/PartitionKind.ts +++ b/sdk/typescript/lib/generated/models/PartitionKind.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PaymentFromVault.ts b/sdk/typescript/lib/generated/models/PaymentFromVault.ts index b32829fd5c..c4fe68d46a 100644 --- a/sdk/typescript/lib/generated/models/PaymentFromVault.ts +++ b/sdk/typescript/lib/generated/models/PaymentFromVault.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PaymentToRoyaltyRecipient.ts b/sdk/typescript/lib/generated/models/PaymentToRoyaltyRecipient.ts index b19fd28546..74128215a1 100644 --- a/sdk/typescript/lib/generated/models/PaymentToRoyaltyRecipient.ts +++ b/sdk/typescript/lib/generated/models/PaymentToRoyaltyRecipient.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PendingOwnerStakeWithdrawal.ts b/sdk/typescript/lib/generated/models/PendingOwnerStakeWithdrawal.ts index 4813b7c3f8..9b5eb86f92 100644 --- a/sdk/typescript/lib/generated/models/PendingOwnerStakeWithdrawal.ts +++ b/sdk/typescript/lib/generated/models/PendingOwnerStakeWithdrawal.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PlaintextMessageContent.ts b/sdk/typescript/lib/generated/models/PlaintextMessageContent.ts index f649bea9e0..0a6b96b6c5 100644 --- a/sdk/typescript/lib/generated/models/PlaintextMessageContent.ts +++ b/sdk/typescript/lib/generated/models/PlaintextMessageContent.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PlaintextMessageContentBase.ts b/sdk/typescript/lib/generated/models/PlaintextMessageContentBase.ts index 72516f630f..866e8be84d 100644 --- a/sdk/typescript/lib/generated/models/PlaintextMessageContentBase.ts +++ b/sdk/typescript/lib/generated/models/PlaintextMessageContentBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PlaintextMessageContentType.ts b/sdk/typescript/lib/generated/models/PlaintextMessageContentType.ts index cc105aa658..3f8c7f2f5c 100644 --- a/sdk/typescript/lib/generated/models/PlaintextMessageContentType.ts +++ b/sdk/typescript/lib/generated/models/PlaintextMessageContentType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PlaintextTransactionMessage.ts b/sdk/typescript/lib/generated/models/PlaintextTransactionMessage.ts index dc94fc57c7..db739ecd73 100644 --- a/sdk/typescript/lib/generated/models/PlaintextTransactionMessage.ts +++ b/sdk/typescript/lib/generated/models/PlaintextTransactionMessage.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PlaintextTransactionMessageAllOf.ts b/sdk/typescript/lib/generated/models/PlaintextTransactionMessageAllOf.ts index b57c32aba5..55e69719e0 100644 --- a/sdk/typescript/lib/generated/models/PlaintextTransactionMessageAllOf.ts +++ b/sdk/typescript/lib/generated/models/PlaintextTransactionMessageAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PoolVault.ts b/sdk/typescript/lib/generated/models/PoolVault.ts index f916552039..c0c2827cef 100644 --- a/sdk/typescript/lib/generated/models/PoolVault.ts +++ b/sdk/typescript/lib/generated/models/PoolVault.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PresentedBadge.ts b/sdk/typescript/lib/generated/models/PresentedBadge.ts index c16b2c2bcb..2e987cd47f 100644 --- a/sdk/typescript/lib/generated/models/PresentedBadge.ts +++ b/sdk/typescript/lib/generated/models/PresentedBadge.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PresentedBadgeBase.ts b/sdk/typescript/lib/generated/models/PresentedBadgeBase.ts index b2b5d6abdd..88be66c640 100644 --- a/sdk/typescript/lib/generated/models/PresentedBadgeBase.ts +++ b/sdk/typescript/lib/generated/models/PresentedBadgeBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PresentedBadgeType.ts b/sdk/typescript/lib/generated/models/PresentedBadgeType.ts index 68bacce96b..bd5fc2724a 100644 --- a/sdk/typescript/lib/generated/models/PresentedBadgeType.ts +++ b/sdk/typescript/lib/generated/models/PresentedBadgeType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PrimaryRoleRecoveryAttempt.ts b/sdk/typescript/lib/generated/models/PrimaryRoleRecoveryAttempt.ts index 0ece47af00..6e64c239e9 100644 --- a/sdk/typescript/lib/generated/models/PrimaryRoleRecoveryAttempt.ts +++ b/sdk/typescript/lib/generated/models/PrimaryRoleRecoveryAttempt.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProofAccessRuleNode.ts b/sdk/typescript/lib/generated/models/ProofAccessRuleNode.ts index e6120165d9..6105339984 100644 --- a/sdk/typescript/lib/generated/models/ProofAccessRuleNode.ts +++ b/sdk/typescript/lib/generated/models/ProofAccessRuleNode.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProofAccessRuleNodeAllOf.ts b/sdk/typescript/lib/generated/models/ProofAccessRuleNodeAllOf.ts index a4292cb020..af187350db 100644 --- a/sdk/typescript/lib/generated/models/ProofAccessRuleNodeAllOf.ts +++ b/sdk/typescript/lib/generated/models/ProofAccessRuleNodeAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProofRule.ts b/sdk/typescript/lib/generated/models/ProofRule.ts index 288716fbb1..5bc660e9bf 100644 --- a/sdk/typescript/lib/generated/models/ProofRule.ts +++ b/sdk/typescript/lib/generated/models/ProofRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProofRuleBase.ts b/sdk/typescript/lib/generated/models/ProofRuleBase.ts index 86f12795e8..c09516ebd1 100644 --- a/sdk/typescript/lib/generated/models/ProofRuleBase.ts +++ b/sdk/typescript/lib/generated/models/ProofRuleBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProofRuleType.ts b/sdk/typescript/lib/generated/models/ProofRuleType.ts index ed5c1b95c5..abecb676d3 100644 --- a/sdk/typescript/lib/generated/models/ProofRuleType.ts +++ b/sdk/typescript/lib/generated/models/ProofRuleType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProposerReward.ts b/sdk/typescript/lib/generated/models/ProposerReward.ts index 41bba8c2f3..768b13fef5 100644 --- a/sdk/typescript/lib/generated/models/ProposerReward.ts +++ b/sdk/typescript/lib/generated/models/ProposerReward.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProtectedAccessRule.ts b/sdk/typescript/lib/generated/models/ProtectedAccessRule.ts index 0843dc02d9..c407e6c035 100644 --- a/sdk/typescript/lib/generated/models/ProtectedAccessRule.ts +++ b/sdk/typescript/lib/generated/models/ProtectedAccessRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProtectedAccessRuleAllOf.ts b/sdk/typescript/lib/generated/models/ProtectedAccessRuleAllOf.ts index 7d6981fccc..3efed4af3b 100644 --- a/sdk/typescript/lib/generated/models/ProtectedAccessRuleAllOf.ts +++ b/sdk/typescript/lib/generated/models/ProtectedAccessRuleAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProtocolUpdateLedgerProofOrigin.ts b/sdk/typescript/lib/generated/models/ProtocolUpdateLedgerProofOrigin.ts index 423c3147dd..ba542b37f4 100644 --- a/sdk/typescript/lib/generated/models/ProtocolUpdateLedgerProofOrigin.ts +++ b/sdk/typescript/lib/generated/models/ProtocolUpdateLedgerProofOrigin.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProtocolUpdateLedgerProofOriginAllOf.ts b/sdk/typescript/lib/generated/models/ProtocolUpdateLedgerProofOriginAllOf.ts index 14cc264fd2..1f8e03d944 100644 --- a/sdk/typescript/lib/generated/models/ProtocolUpdateLedgerProofOriginAllOf.ts +++ b/sdk/typescript/lib/generated/models/ProtocolUpdateLedgerProofOriginAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ProtocolVersionReadiness.ts b/sdk/typescript/lib/generated/models/ProtocolVersionReadiness.ts index d2d64f9ddf..f9e8529709 100644 --- a/sdk/typescript/lib/generated/models/ProtocolVersionReadiness.ts +++ b/sdk/typescript/lib/generated/models/ProtocolVersionReadiness.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PublicKey.ts b/sdk/typescript/lib/generated/models/PublicKey.ts index 97a254e160..dc5f218117 100644 --- a/sdk/typescript/lib/generated/models/PublicKey.ts +++ b/sdk/typescript/lib/generated/models/PublicKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PublicKeyBase.ts b/sdk/typescript/lib/generated/models/PublicKeyBase.ts index edb7e65fc3..74bffbfe35 100644 --- a/sdk/typescript/lib/generated/models/PublicKeyBase.ts +++ b/sdk/typescript/lib/generated/models/PublicKeyBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PublicKeyType.ts b/sdk/typescript/lib/generated/models/PublicKeyType.ts index c62bcf7817..8eb039af5a 100644 --- a/sdk/typescript/lib/generated/models/PublicKeyType.ts +++ b/sdk/typescript/lib/generated/models/PublicKeyType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PublicMethodAccessibility.ts b/sdk/typescript/lib/generated/models/PublicMethodAccessibility.ts index cec9806a91..5f30b94243 100644 --- a/sdk/typescript/lib/generated/models/PublicMethodAccessibility.ts +++ b/sdk/typescript/lib/generated/models/PublicMethodAccessibility.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/PublicMethodAccessibilityAllOf.ts b/sdk/typescript/lib/generated/models/PublicMethodAccessibilityAllOf.ts index 6064860293..d53cbd8531 100644 --- a/sdk/typescript/lib/generated/models/PublicMethodAccessibilityAllOf.ts +++ b/sdk/typescript/lib/generated/models/PublicMethodAccessibilityAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ReceiverInfo.ts b/sdk/typescript/lib/generated/models/ReceiverInfo.ts index 9f46148a7e..ff701c2074 100644 --- a/sdk/typescript/lib/generated/models/ReceiverInfo.ts +++ b/sdk/typescript/lib/generated/models/ReceiverInfo.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RecoveryProposal.ts b/sdk/typescript/lib/generated/models/RecoveryProposal.ts index 8821775a30..07705276d2 100644 --- a/sdk/typescript/lib/generated/models/RecoveryProposal.ts +++ b/sdk/typescript/lib/generated/models/RecoveryProposal.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RecoveryRoleRecoveryAttempt.ts b/sdk/typescript/lib/generated/models/RecoveryRoleRecoveryAttempt.ts index 66e800c61a..bb6953a2f8 100644 --- a/sdk/typescript/lib/generated/models/RecoveryRoleRecoveryAttempt.ts +++ b/sdk/typescript/lib/generated/models/RecoveryRoleRecoveryAttempt.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ReferenceType.ts b/sdk/typescript/lib/generated/models/ReferenceType.ts index 0eaab10cb5..96e1797341 100644 --- a/sdk/typescript/lib/generated/models/ReferenceType.ts +++ b/sdk/typescript/lib/generated/models/ReferenceType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RemoteGenericSubstitution.ts b/sdk/typescript/lib/generated/models/RemoteGenericSubstitution.ts index 0775fd98ad..0be28b4b70 100644 --- a/sdk/typescript/lib/generated/models/RemoteGenericSubstitution.ts +++ b/sdk/typescript/lib/generated/models/RemoteGenericSubstitution.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RemoteGenericSubstitutionAllOf.ts b/sdk/typescript/lib/generated/models/RemoteGenericSubstitutionAllOf.ts index 1d7f058690..1635d60e0c 100644 --- a/sdk/typescript/lib/generated/models/RemoteGenericSubstitutionAllOf.ts +++ b/sdk/typescript/lib/generated/models/RemoteGenericSubstitutionAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RequestedStateVersionOutOfBoundsErrorDetails.ts b/sdk/typescript/lib/generated/models/RequestedStateVersionOutOfBoundsErrorDetails.ts index 4a44f7fb46..49b9763021 100644 --- a/sdk/typescript/lib/generated/models/RequestedStateVersionOutOfBoundsErrorDetails.ts +++ b/sdk/typescript/lib/generated/models/RequestedStateVersionOutOfBoundsErrorDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RequireProofRule.ts b/sdk/typescript/lib/generated/models/RequireProofRule.ts index 10670313f5..031e12dbb6 100644 --- a/sdk/typescript/lib/generated/models/RequireProofRule.ts +++ b/sdk/typescript/lib/generated/models/RequireProofRule.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RequireProofRuleAllOf.ts b/sdk/typescript/lib/generated/models/RequireProofRuleAllOf.ts index 265dccc632..241003d8cb 100644 --- a/sdk/typescript/lib/generated/models/RequireProofRuleAllOf.ts +++ b/sdk/typescript/lib/generated/models/RequireProofRuleAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/Requirement.ts b/sdk/typescript/lib/generated/models/Requirement.ts index 4c098df57c..46c59a0c4c 100644 --- a/sdk/typescript/lib/generated/models/Requirement.ts +++ b/sdk/typescript/lib/generated/models/Requirement.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RequirementBase.ts b/sdk/typescript/lib/generated/models/RequirementBase.ts index 9f07a5c2c7..7030eaa658 100644 --- a/sdk/typescript/lib/generated/models/RequirementBase.ts +++ b/sdk/typescript/lib/generated/models/RequirementBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RequirementType.ts b/sdk/typescript/lib/generated/models/RequirementType.ts index a35621270f..bab2301426 100644 --- a/sdk/typescript/lib/generated/models/RequirementType.ts +++ b/sdk/typescript/lib/generated/models/RequirementType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceAmount.ts b/sdk/typescript/lib/generated/models/ResourceAmount.ts index 6a4ae38caf..64e8744d98 100644 --- a/sdk/typescript/lib/generated/models/ResourceAmount.ts +++ b/sdk/typescript/lib/generated/models/ResourceAmount.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceAmountBase.ts b/sdk/typescript/lib/generated/models/ResourceAmountBase.ts index 39912f268d..1d8dd48c29 100644 --- a/sdk/typescript/lib/generated/models/ResourceAmountBase.ts +++ b/sdk/typescript/lib/generated/models/ResourceAmountBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceAuthorizedDepositorBadge.ts b/sdk/typescript/lib/generated/models/ResourceAuthorizedDepositorBadge.ts index 05a00800e1..1728ca3407 100644 --- a/sdk/typescript/lib/generated/models/ResourceAuthorizedDepositorBadge.ts +++ b/sdk/typescript/lib/generated/models/ResourceAuthorizedDepositorBadge.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceAuthorizedDepositorBadgeAllOf.ts b/sdk/typescript/lib/generated/models/ResourceAuthorizedDepositorBadgeAllOf.ts index fcad7431a1..3bdf1bc94b 100644 --- a/sdk/typescript/lib/generated/models/ResourceAuthorizedDepositorBadgeAllOf.ts +++ b/sdk/typescript/lib/generated/models/ResourceAuthorizedDepositorBadgeAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceChange.ts b/sdk/typescript/lib/generated/models/ResourceChange.ts index 9005b634e2..c53d081a39 100644 --- a/sdk/typescript/lib/generated/models/ResourceChange.ts +++ b/sdk/typescript/lib/generated/models/ResourceChange.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceKey.ts b/sdk/typescript/lib/generated/models/ResourceKey.ts index b8abee90fe..71e4e6b919 100644 --- a/sdk/typescript/lib/generated/models/ResourceKey.ts +++ b/sdk/typescript/lib/generated/models/ResourceKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourcePreference.ts b/sdk/typescript/lib/generated/models/ResourcePreference.ts index 4a009d6f76..b00b1543b0 100644 --- a/sdk/typescript/lib/generated/models/ResourcePreference.ts +++ b/sdk/typescript/lib/generated/models/ResourcePreference.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourcePresentedBadge.ts b/sdk/typescript/lib/generated/models/ResourcePresentedBadge.ts index 19effa6ecb..678bd53454 100644 --- a/sdk/typescript/lib/generated/models/ResourcePresentedBadge.ts +++ b/sdk/typescript/lib/generated/models/ResourcePresentedBadge.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourcePresentedBadgeAllOf.ts b/sdk/typescript/lib/generated/models/ResourcePresentedBadgeAllOf.ts index af9669fb0c..6fd4cfc3d2 100644 --- a/sdk/typescript/lib/generated/models/ResourcePresentedBadgeAllOf.ts +++ b/sdk/typescript/lib/generated/models/ResourcePresentedBadgeAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceRequirement.ts b/sdk/typescript/lib/generated/models/ResourceRequirement.ts index 7e1ef3fab6..1f1d5a1fab 100644 --- a/sdk/typescript/lib/generated/models/ResourceRequirement.ts +++ b/sdk/typescript/lib/generated/models/ResourceRequirement.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceRequirementAllOf.ts b/sdk/typescript/lib/generated/models/ResourceRequirementAllOf.ts index 15b5ba9172..04e6a4534d 100644 --- a/sdk/typescript/lib/generated/models/ResourceRequirementAllOf.ts +++ b/sdk/typescript/lib/generated/models/ResourceRequirementAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceSpecificDepositBehaviour.ts b/sdk/typescript/lib/generated/models/ResourceSpecificDepositBehaviour.ts index 63340427f0..16a3c66dd6 100644 --- a/sdk/typescript/lib/generated/models/ResourceSpecificDepositBehaviour.ts +++ b/sdk/typescript/lib/generated/models/ResourceSpecificDepositBehaviour.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ResourceType.ts b/sdk/typescript/lib/generated/models/ResourceType.ts index 256344d37b..9e0ca66c19 100644 --- a/sdk/typescript/lib/generated/models/ResourceType.ts +++ b/sdk/typescript/lib/generated/models/ResourceType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstate.ts b/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstate.ts index cc532a1192..1e14b2cea7 100644 --- a/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstate.ts +++ b/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstateAllOf.ts b/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstateAllOf.ts index 079b2916cf..c9f0394ca1 100644 --- a/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleValue.ts b/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleValue.ts index 744696b098..c107e7cc32 100644 --- a/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleValue.ts +++ b/sdk/typescript/lib/generated/models/RoleAssignmentModuleFieldOwnerRoleValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntrySubstate.ts b/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntrySubstate.ts index 5396087150..cf03fc1927 100644 --- a/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntrySubstateAllOf.ts index dfbacc2c8b..71d5e90f0a 100644 --- a/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntryValue.ts b/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntryValue.ts index 88d4f11c0e..05fcc590ff 100644 --- a/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntryValue.ts +++ b/sdk/typescript/lib/generated/models/RoleAssignmentModuleRuleEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleDetails.ts b/sdk/typescript/lib/generated/models/RoleDetails.ts index fca6ace6b0..6beda754af 100644 --- a/sdk/typescript/lib/generated/models/RoleDetails.ts +++ b/sdk/typescript/lib/generated/models/RoleDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleProtectedMethodAccessibility.ts b/sdk/typescript/lib/generated/models/RoleProtectedMethodAccessibility.ts index f24487400a..09e062fd42 100644 --- a/sdk/typescript/lib/generated/models/RoleProtectedMethodAccessibility.ts +++ b/sdk/typescript/lib/generated/models/RoleProtectedMethodAccessibility.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleProtectedMethodAccessibilityAllOf.ts b/sdk/typescript/lib/generated/models/RoleProtectedMethodAccessibilityAllOf.ts index 9dbc56d5d5..6ca827a845 100644 --- a/sdk/typescript/lib/generated/models/RoleProtectedMethodAccessibilityAllOf.ts +++ b/sdk/typescript/lib/generated/models/RoleProtectedMethodAccessibilityAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoleSpecification.ts b/sdk/typescript/lib/generated/models/RoleSpecification.ts index ad5e94ea64..5c02d1e314 100644 --- a/sdk/typescript/lib/generated/models/RoleSpecification.ts +++ b/sdk/typescript/lib/generated/models/RoleSpecification.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoundUpdateLedgerTransaction.ts b/sdk/typescript/lib/generated/models/RoundUpdateLedgerTransaction.ts index 9e5fe53632..a462a4da1b 100644 --- a/sdk/typescript/lib/generated/models/RoundUpdateLedgerTransaction.ts +++ b/sdk/typescript/lib/generated/models/RoundUpdateLedgerTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoundUpdateLedgerTransactionAllOf.ts b/sdk/typescript/lib/generated/models/RoundUpdateLedgerTransactionAllOf.ts index 85a956d120..2c271d3d4d 100644 --- a/sdk/typescript/lib/generated/models/RoundUpdateLedgerTransactionAllOf.ts +++ b/sdk/typescript/lib/generated/models/RoundUpdateLedgerTransactionAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoundUpdateTransaction.ts b/sdk/typescript/lib/generated/models/RoundUpdateTransaction.ts index 867a16af4f..94676d09ff 100644 --- a/sdk/typescript/lib/generated/models/RoundUpdateTransaction.ts +++ b/sdk/typescript/lib/generated/models/RoundUpdateTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoyaltyAmount.ts b/sdk/typescript/lib/generated/models/RoyaltyAmount.ts index d3e5149aaa..566c1ed628 100644 --- a/sdk/typescript/lib/generated/models/RoyaltyAmount.ts +++ b/sdk/typescript/lib/generated/models/RoyaltyAmount.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateSubstate.ts index 5e8d236d63..c274973dab 100644 --- a/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateSubstateAllOf.ts index 1ebc2965e0..c87f23e08b 100644 --- a/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateValue.ts b/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateValue.ts index ae00c6c8a3..2f6d3e17b1 100644 --- a/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/RoyaltyModuleFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstate.ts b/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstate.ts index 266a27034e..651a039c99 100644 --- a/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstateAllOf.ts index ba6171d7b4..38c3399795 100644 --- a/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntryValue.ts b/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntryValue.ts index 333f41e51d..1242706292 100644 --- a/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntryValue.ts +++ b/sdk/typescript/lib/generated/models/RoyaltyModuleMethodRoyaltyEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SborData.ts b/sdk/typescript/lib/generated/models/SborData.ts index 806047efd9..28c61dfd11 100644 --- a/sdk/typescript/lib/generated/models/SborData.ts +++ b/sdk/typescript/lib/generated/models/SborData.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SborFormatOptions.ts b/sdk/typescript/lib/generated/models/SborFormatOptions.ts index d3970b95e2..ebfc6c6d24 100644 --- a/sdk/typescript/lib/generated/models/SborFormatOptions.ts +++ b/sdk/typescript/lib/generated/models/SborFormatOptions.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ScenariosRequest.ts b/sdk/typescript/lib/generated/models/ScenariosRequest.ts index 03d972c00b..c31f659804 100644 --- a/sdk/typescript/lib/generated/models/ScenariosRequest.ts +++ b/sdk/typescript/lib/generated/models/ScenariosRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ScenariosResponse.ts b/sdk/typescript/lib/generated/models/ScenariosResponse.ts index e5628b5866..ebc481e2ba 100644 --- a/sdk/typescript/lib/generated/models/ScenariosResponse.ts +++ b/sdk/typescript/lib/generated/models/ScenariosResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SchemaEntrySubstate.ts b/sdk/typescript/lib/generated/models/SchemaEntrySubstate.ts index 87d059048a..b56ac0d640 100644 --- a/sdk/typescript/lib/generated/models/SchemaEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/SchemaEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SchemaEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/SchemaEntrySubstateAllOf.ts index 9a2a543e20..daab9ce091 100644 --- a/sdk/typescript/lib/generated/models/SchemaEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/SchemaEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SchemaEntryValue.ts b/sdk/typescript/lib/generated/models/SchemaEntryValue.ts index cea7a8e2d6..1f82c57203 100644 --- a/sdk/typescript/lib/generated/models/SchemaEntryValue.ts +++ b/sdk/typescript/lib/generated/models/SchemaEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SchemaKey.ts b/sdk/typescript/lib/generated/models/SchemaKey.ts index bbf54b01e4..acbbeb4a99 100644 --- a/sdk/typescript/lib/generated/models/SchemaKey.ts +++ b/sdk/typescript/lib/generated/models/SchemaKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ScopedTypeId.ts b/sdk/typescript/lib/generated/models/ScopedTypeId.ts index f9283c2ef2..49306e77b7 100644 --- a/sdk/typescript/lib/generated/models/ScopedTypeId.ts +++ b/sdk/typescript/lib/generated/models/ScopedTypeId.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ScryptoSchema.ts b/sdk/typescript/lib/generated/models/ScryptoSchema.ts index 55459dbc38..b98692f9e3 100644 --- a/sdk/typescript/lib/generated/models/ScryptoSchema.ts +++ b/sdk/typescript/lib/generated/models/ScryptoSchema.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SignallingValidator.ts b/sdk/typescript/lib/generated/models/SignallingValidator.ts index 3491dc5f36..2a0f8e1b07 100644 --- a/sdk/typescript/lib/generated/models/SignallingValidator.ts +++ b/sdk/typescript/lib/generated/models/SignallingValidator.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/Signature.ts b/sdk/typescript/lib/generated/models/Signature.ts index 4b02469907..8c7dc7b7e0 100644 --- a/sdk/typescript/lib/generated/models/Signature.ts +++ b/sdk/typescript/lib/generated/models/Signature.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SignatureBase.ts b/sdk/typescript/lib/generated/models/SignatureBase.ts index 145eb51b6c..6a8b9d83f7 100644 --- a/sdk/typescript/lib/generated/models/SignatureBase.ts +++ b/sdk/typescript/lib/generated/models/SignatureBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SignatureWithPublicKey.ts b/sdk/typescript/lib/generated/models/SignatureWithPublicKey.ts index b2e1131686..399e4542a4 100644 --- a/sdk/typescript/lib/generated/models/SignatureWithPublicKey.ts +++ b/sdk/typescript/lib/generated/models/SignatureWithPublicKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SignatureWithPublicKeyBase.ts b/sdk/typescript/lib/generated/models/SignatureWithPublicKeyBase.ts index d66d38eb31..4f73bf311c 100644 --- a/sdk/typescript/lib/generated/models/SignatureWithPublicKeyBase.ts +++ b/sdk/typescript/lib/generated/models/SignatureWithPublicKeyBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SignedTransactionIntent.ts b/sdk/typescript/lib/generated/models/SignedTransactionIntent.ts index 0fc52e8e3f..cb6489ce5f 100644 --- a/sdk/typescript/lib/generated/models/SignedTransactionIntent.ts +++ b/sdk/typescript/lib/generated/models/SignedTransactionIntent.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SignificantProtocolUpdateReadinessEntry.ts b/sdk/typescript/lib/generated/models/SignificantProtocolUpdateReadinessEntry.ts index 8b97a1ec86..a88132b54b 100644 --- a/sdk/typescript/lib/generated/models/SignificantProtocolUpdateReadinessEntry.ts +++ b/sdk/typescript/lib/generated/models/SignificantProtocolUpdateReadinessEntry.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SortedIndexBlueprintCollectionSchema.ts b/sdk/typescript/lib/generated/models/SortedIndexBlueprintCollectionSchema.ts index 0964194209..34261701d2 100644 --- a/sdk/typescript/lib/generated/models/SortedIndexBlueprintCollectionSchema.ts +++ b/sdk/typescript/lib/generated/models/SortedIndexBlueprintCollectionSchema.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SortedIndexBlueprintCollectionSchemaAllOf.ts b/sdk/typescript/lib/generated/models/SortedIndexBlueprintCollectionSchemaAllOf.ts index 2207a55e13..65dbab5112 100644 --- a/sdk/typescript/lib/generated/models/SortedIndexBlueprintCollectionSchemaAllOf.ts +++ b/sdk/typescript/lib/generated/models/SortedIndexBlueprintCollectionSchemaAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SortedSubstateKey.ts b/sdk/typescript/lib/generated/models/SortedSubstateKey.ts index fab0649e7c..ee8d32fbf7 100644 --- a/sdk/typescript/lib/generated/models/SortedSubstateKey.ts +++ b/sdk/typescript/lib/generated/models/SortedSubstateKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SortedSubstateKeyAllOf.ts b/sdk/typescript/lib/generated/models/SortedSubstateKeyAllOf.ts index b325c8c3e7..ece715a234 100644 --- a/sdk/typescript/lib/generated/models/SortedSubstateKeyAllOf.ts +++ b/sdk/typescript/lib/generated/models/SortedSubstateKeyAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateAccessControllerRequest.ts b/sdk/typescript/lib/generated/models/StateAccessControllerRequest.ts index 1a75d4e2da..f04b7668c5 100644 --- a/sdk/typescript/lib/generated/models/StateAccessControllerRequest.ts +++ b/sdk/typescript/lib/generated/models/StateAccessControllerRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateAccessControllerResponse.ts b/sdk/typescript/lib/generated/models/StateAccessControllerResponse.ts index 702a9f27bb..dc51da543b 100644 --- a/sdk/typescript/lib/generated/models/StateAccessControllerResponse.ts +++ b/sdk/typescript/lib/generated/models/StateAccessControllerResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateAccountRequest.ts b/sdk/typescript/lib/generated/models/StateAccountRequest.ts index 0431e95299..5235ce2a44 100644 --- a/sdk/typescript/lib/generated/models/StateAccountRequest.ts +++ b/sdk/typescript/lib/generated/models/StateAccountRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateAccountResponse.ts b/sdk/typescript/lib/generated/models/StateAccountResponse.ts index b4fa8ace25..7719ea508d 100644 --- a/sdk/typescript/lib/generated/models/StateAccountResponse.ts +++ b/sdk/typescript/lib/generated/models/StateAccountResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateComponentDescendentNode.ts b/sdk/typescript/lib/generated/models/StateComponentDescendentNode.ts index c081083b38..876b775f07 100644 --- a/sdk/typescript/lib/generated/models/StateComponentDescendentNode.ts +++ b/sdk/typescript/lib/generated/models/StateComponentDescendentNode.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateComponentRequest.ts b/sdk/typescript/lib/generated/models/StateComponentRequest.ts index 719eaab8fd..fa9021dfe8 100644 --- a/sdk/typescript/lib/generated/models/StateComponentRequest.ts +++ b/sdk/typescript/lib/generated/models/StateComponentRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateComponentResponse.ts b/sdk/typescript/lib/generated/models/StateComponentResponse.ts index b9eace966a..76407e5aa1 100644 --- a/sdk/typescript/lib/generated/models/StateComponentResponse.ts +++ b/sdk/typescript/lib/generated/models/StateComponentResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateConsensusManagerRequest.ts b/sdk/typescript/lib/generated/models/StateConsensusManagerRequest.ts index cf3ebb26e3..69ab2407a8 100644 --- a/sdk/typescript/lib/generated/models/StateConsensusManagerRequest.ts +++ b/sdk/typescript/lib/generated/models/StateConsensusManagerRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateConsensusManagerResponse.ts b/sdk/typescript/lib/generated/models/StateConsensusManagerResponse.ts index a5bdcac41a..4c0b5e2273 100644 --- a/sdk/typescript/lib/generated/models/StateConsensusManagerResponse.ts +++ b/sdk/typescript/lib/generated/models/StateConsensusManagerResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateFungibleResourceManager.ts b/sdk/typescript/lib/generated/models/StateFungibleResourceManager.ts index 1d9de8f861..bef279e342 100644 --- a/sdk/typescript/lib/generated/models/StateFungibleResourceManager.ts +++ b/sdk/typescript/lib/generated/models/StateFungibleResourceManager.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateFungibleResourceManagerAllOf.ts b/sdk/typescript/lib/generated/models/StateFungibleResourceManagerAllOf.ts index 644158475e..7d16bba26a 100644 --- a/sdk/typescript/lib/generated/models/StateFungibleResourceManagerAllOf.ts +++ b/sdk/typescript/lib/generated/models/StateFungibleResourceManagerAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateNonFungibleRequest.ts b/sdk/typescript/lib/generated/models/StateNonFungibleRequest.ts index dff37d579a..aaf7392fb1 100644 --- a/sdk/typescript/lib/generated/models/StateNonFungibleRequest.ts +++ b/sdk/typescript/lib/generated/models/StateNonFungibleRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateNonFungibleResourceManager.ts b/sdk/typescript/lib/generated/models/StateNonFungibleResourceManager.ts index c85314fde9..98e381a1b6 100644 --- a/sdk/typescript/lib/generated/models/StateNonFungibleResourceManager.ts +++ b/sdk/typescript/lib/generated/models/StateNonFungibleResourceManager.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateNonFungibleResourceManagerAllOf.ts b/sdk/typescript/lib/generated/models/StateNonFungibleResourceManagerAllOf.ts index e3d3417af6..2078756786 100644 --- a/sdk/typescript/lib/generated/models/StateNonFungibleResourceManagerAllOf.ts +++ b/sdk/typescript/lib/generated/models/StateNonFungibleResourceManagerAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateNonFungibleResponse.ts b/sdk/typescript/lib/generated/models/StateNonFungibleResponse.ts index cb4b488dcd..993041c7ac 100644 --- a/sdk/typescript/lib/generated/models/StateNonFungibleResponse.ts +++ b/sdk/typescript/lib/generated/models/StateNonFungibleResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StatePackageRequest.ts b/sdk/typescript/lib/generated/models/StatePackageRequest.ts index e94ee0f6a1..d3fc7e5ded 100644 --- a/sdk/typescript/lib/generated/models/StatePackageRequest.ts +++ b/sdk/typescript/lib/generated/models/StatePackageRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StatePackageResponse.ts b/sdk/typescript/lib/generated/models/StatePackageResponse.ts index 5212f6ccd3..7a1e8f1bff 100644 --- a/sdk/typescript/lib/generated/models/StatePackageResponse.ts +++ b/sdk/typescript/lib/generated/models/StatePackageResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateResourceManager.ts b/sdk/typescript/lib/generated/models/StateResourceManager.ts index 260b89c733..75d86763f1 100644 --- a/sdk/typescript/lib/generated/models/StateResourceManager.ts +++ b/sdk/typescript/lib/generated/models/StateResourceManager.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateResourceManagerBase.ts b/sdk/typescript/lib/generated/models/StateResourceManagerBase.ts index 7fed5a5705..c9110ff743 100644 --- a/sdk/typescript/lib/generated/models/StateResourceManagerBase.ts +++ b/sdk/typescript/lib/generated/models/StateResourceManagerBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateResourceRequest.ts b/sdk/typescript/lib/generated/models/StateResourceRequest.ts index 6f517fb0bb..d5897b39ec 100644 --- a/sdk/typescript/lib/generated/models/StateResourceRequest.ts +++ b/sdk/typescript/lib/generated/models/StateResourceRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateResourceResponse.ts b/sdk/typescript/lib/generated/models/StateResourceResponse.ts index 00c1853fb7..364318bfaa 100644 --- a/sdk/typescript/lib/generated/models/StateResourceResponse.ts +++ b/sdk/typescript/lib/generated/models/StateResourceResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateUpdates.ts b/sdk/typescript/lib/generated/models/StateUpdates.ts index 1cce58b0a1..3e7f707283 100644 --- a/sdk/typescript/lib/generated/models/StateUpdates.ts +++ b/sdk/typescript/lib/generated/models/StateUpdates.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateValidatorRequest.ts b/sdk/typescript/lib/generated/models/StateValidatorRequest.ts index 1d297bce2f..25d2e169f1 100644 --- a/sdk/typescript/lib/generated/models/StateValidatorRequest.ts +++ b/sdk/typescript/lib/generated/models/StateValidatorRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StateValidatorResponse.ts b/sdk/typescript/lib/generated/models/StateValidatorResponse.ts index f87709ac6f..8279dea7ca 100644 --- a/sdk/typescript/lib/generated/models/StateValidatorResponse.ts +++ b/sdk/typescript/lib/generated/models/StateValidatorResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StaticBlueprintPayloadDef.ts b/sdk/typescript/lib/generated/models/StaticBlueprintPayloadDef.ts index 9be95430fe..105518e63e 100644 --- a/sdk/typescript/lib/generated/models/StaticBlueprintPayloadDef.ts +++ b/sdk/typescript/lib/generated/models/StaticBlueprintPayloadDef.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StaticBlueprintPayloadDefAllOf.ts b/sdk/typescript/lib/generated/models/StaticBlueprintPayloadDefAllOf.ts index 11ec5b6e09..fcce54e225 100644 --- a/sdk/typescript/lib/generated/models/StaticBlueprintPayloadDefAllOf.ts +++ b/sdk/typescript/lib/generated/models/StaticBlueprintPayloadDefAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StaticRoleDefinitionAuthTemplate.ts b/sdk/typescript/lib/generated/models/StaticRoleDefinitionAuthTemplate.ts index 580267573a..2b1e4c498c 100644 --- a/sdk/typescript/lib/generated/models/StaticRoleDefinitionAuthTemplate.ts +++ b/sdk/typescript/lib/generated/models/StaticRoleDefinitionAuthTemplate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsErrorDetails.ts b/sdk/typescript/lib/generated/models/StreamProofsErrorDetails.ts index ef314a6abb..124b3c93fb 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsErrorDetails.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsErrorDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsBase.ts b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsBase.ts index 5ddaefa702..2c81d6d566 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsBase.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBounds.ts b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBounds.ts index 6572aa18eb..fbdfca3b8a 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBounds.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBounds.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBoundsAllOf.ts b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBoundsAllOf.ts index 44ff0154c1..17b570d124 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBoundsAllOf.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedEpochOutOfBoundsAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBounds.ts b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBounds.ts index 7b2621f62a..952c3d9f5a 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBounds.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBounds.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBoundsAllOf.ts b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBoundsAllOf.ts index e502f2458e..cc82fe1d24 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBoundsAllOf.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsRequestedStateVersionOutOfBoundsAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsType.ts b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsType.ts index 4de1d9e69e..ffe1a348df 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsType.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsErrorDetailsType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsErrorResponse.ts b/sdk/typescript/lib/generated/models/StreamProofsErrorResponse.ts index db38bf0ad5..2641d642c5 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsErrorResponse.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsErrorResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsErrorResponseAllOf.ts b/sdk/typescript/lib/generated/models/StreamProofsErrorResponseAllOf.ts index e241ca11dc..c5095cd010 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsErrorResponseAllOf.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsErrorResponseAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilter.ts b/sdk/typescript/lib/generated/models/StreamProofsFilter.ts index 345051d3a6..0fff38e131 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilter.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilter.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterAny.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterAny.ts index 74db16af65..1ecc1bce06 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterAny.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterAny.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterAnyAllOf.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterAnyAllOf.ts index cac1209210..2da39a4f3d 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterAnyAllOf.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterAnyAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterBase.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterBase.ts index f9d5e62685..31c6939948 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterBase.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterNewEpochs.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterNewEpochs.ts index 9b31b065de..4e596d2466 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterNewEpochs.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterNewEpochs.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterNewEpochsAllOf.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterNewEpochsAllOf.ts index 51b2a21d51..f62648133e 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterNewEpochsAllOf.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterNewEpochsAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateExecution.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateExecution.ts index d70d483f69..9518ce1643 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateExecution.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateExecution.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateExecutionAllOf.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateExecutionAllOf.ts index 5e291eac44..8777815a3f 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateExecutionAllOf.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateExecutionAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateInitializations.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateInitializations.ts index d820f58352..6faba578cd 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateInitializations.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateInitializations.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateInitializationsAllOf.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateInitializationsAllOf.ts index f2d06e8761..f2fb2cff08 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateInitializationsAllOf.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterProtocolUpdateInitializationsAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsFilterType.ts b/sdk/typescript/lib/generated/models/StreamProofsFilterType.ts index a44062d5bb..ffd900704e 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsFilterType.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsFilterType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsRequest.ts b/sdk/typescript/lib/generated/models/StreamProofsRequest.ts index 051a4ee012..ea201e9c3b 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsRequest.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamProofsResponse.ts b/sdk/typescript/lib/generated/models/StreamProofsResponse.ts index 96e713bc69..d3a2b26ccc 100644 --- a/sdk/typescript/lib/generated/models/StreamProofsResponse.ts +++ b/sdk/typescript/lib/generated/models/StreamProofsResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetails.ts b/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetails.ts index 1e178953f9..c3efb59e30 100644 --- a/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetails.ts +++ b/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetailsBase.ts b/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetailsBase.ts index 2e1e5b4320..964bfec3d3 100644 --- a/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetailsBase.ts +++ b/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetailsBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetailsType.ts b/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetailsType.ts index 2bd3a0d0c4..3b80796abd 100644 --- a/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetailsType.ts +++ b/sdk/typescript/lib/generated/models/StreamTransactionsErrorDetailsType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamTransactionsErrorResponse.ts b/sdk/typescript/lib/generated/models/StreamTransactionsErrorResponse.ts index 04b3e5b913..18975cd483 100644 --- a/sdk/typescript/lib/generated/models/StreamTransactionsErrorResponse.ts +++ b/sdk/typescript/lib/generated/models/StreamTransactionsErrorResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamTransactionsErrorResponseAllOf.ts b/sdk/typescript/lib/generated/models/StreamTransactionsErrorResponseAllOf.ts index 6fb5e99d0d..e7d09d6689 100644 --- a/sdk/typescript/lib/generated/models/StreamTransactionsErrorResponseAllOf.ts +++ b/sdk/typescript/lib/generated/models/StreamTransactionsErrorResponseAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamTransactionsRequest.ts b/sdk/typescript/lib/generated/models/StreamTransactionsRequest.ts index 0284c89e6d..7e1a9a3c84 100644 --- a/sdk/typescript/lib/generated/models/StreamTransactionsRequest.ts +++ b/sdk/typescript/lib/generated/models/StreamTransactionsRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StreamTransactionsResponse.ts b/sdk/typescript/lib/generated/models/StreamTransactionsResponse.ts index 91664c4da3..eb271edc79 100644 --- a/sdk/typescript/lib/generated/models/StreamTransactionsResponse.ts +++ b/sdk/typescript/lib/generated/models/StreamTransactionsResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StringPlaintextMessageContent.ts b/sdk/typescript/lib/generated/models/StringPlaintextMessageContent.ts index 4bbec4387d..f759f7f8f9 100644 --- a/sdk/typescript/lib/generated/models/StringPlaintextMessageContent.ts +++ b/sdk/typescript/lib/generated/models/StringPlaintextMessageContent.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/StringPlaintextMessageContentAllOf.ts b/sdk/typescript/lib/generated/models/StringPlaintextMessageContentAllOf.ts index 2df506579a..fb300795ee 100644 --- a/sdk/typescript/lib/generated/models/StringPlaintextMessageContentAllOf.ts +++ b/sdk/typescript/lib/generated/models/StringPlaintextMessageContentAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/Substate.ts b/sdk/typescript/lib/generated/models/Substate.ts index 7d180ec8a5..97ac8d460f 100644 --- a/sdk/typescript/lib/generated/models/Substate.ts +++ b/sdk/typescript/lib/generated/models/Substate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateBase.ts b/sdk/typescript/lib/generated/models/SubstateBase.ts index 152ac8d08c..22289c7408 100644 --- a/sdk/typescript/lib/generated/models/SubstateBase.ts +++ b/sdk/typescript/lib/generated/models/SubstateBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateFormatOptions.ts b/sdk/typescript/lib/generated/models/SubstateFormatOptions.ts index c3b077aa29..470fdf9452 100644 --- a/sdk/typescript/lib/generated/models/SubstateFormatOptions.ts +++ b/sdk/typescript/lib/generated/models/SubstateFormatOptions.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateId.ts b/sdk/typescript/lib/generated/models/SubstateId.ts index 669bc32ac5..51a6a24967 100644 --- a/sdk/typescript/lib/generated/models/SubstateId.ts +++ b/sdk/typescript/lib/generated/models/SubstateId.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateIdAllOf.ts b/sdk/typescript/lib/generated/models/SubstateIdAllOf.ts index 817a71bf5d..ff8459e741 100644 --- a/sdk/typescript/lib/generated/models/SubstateIdAllOf.ts +++ b/sdk/typescript/lib/generated/models/SubstateIdAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateKey.ts b/sdk/typescript/lib/generated/models/SubstateKey.ts index 8ac193019c..67318c74bd 100644 --- a/sdk/typescript/lib/generated/models/SubstateKey.ts +++ b/sdk/typescript/lib/generated/models/SubstateKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateKeyBase.ts b/sdk/typescript/lib/generated/models/SubstateKeyBase.ts index 977097e48b..ba11021a0c 100644 --- a/sdk/typescript/lib/generated/models/SubstateKeyBase.ts +++ b/sdk/typescript/lib/generated/models/SubstateKeyBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateKeyType.ts b/sdk/typescript/lib/generated/models/SubstateKeyType.ts index baeecccd68..9875e9176b 100644 --- a/sdk/typescript/lib/generated/models/SubstateKeyType.ts +++ b/sdk/typescript/lib/generated/models/SubstateKeyType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateSystemStructure.ts b/sdk/typescript/lib/generated/models/SubstateSystemStructure.ts index 38ab85f020..b5ba1db21c 100644 --- a/sdk/typescript/lib/generated/models/SubstateSystemStructure.ts +++ b/sdk/typescript/lib/generated/models/SubstateSystemStructure.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateSystemStructureBase.ts b/sdk/typescript/lib/generated/models/SubstateSystemStructureBase.ts index 8268d2ae85..94aeb16808 100644 --- a/sdk/typescript/lib/generated/models/SubstateSystemStructureBase.ts +++ b/sdk/typescript/lib/generated/models/SubstateSystemStructureBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateSystemStructureType.ts b/sdk/typescript/lib/generated/models/SubstateSystemStructureType.ts index f3a6230627..2e50d9bc1e 100644 --- a/sdk/typescript/lib/generated/models/SubstateSystemStructureType.ts +++ b/sdk/typescript/lib/generated/models/SubstateSystemStructureType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateType.ts b/sdk/typescript/lib/generated/models/SubstateType.ts index 0212f7a882..df78f1cd9d 100644 --- a/sdk/typescript/lib/generated/models/SubstateType.ts +++ b/sdk/typescript/lib/generated/models/SubstateType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SubstateValue.ts b/sdk/typescript/lib/generated/models/SubstateValue.ts index 2cb187dc01..602ee2b2a3 100644 --- a/sdk/typescript/lib/generated/models/SubstateValue.ts +++ b/sdk/typescript/lib/generated/models/SubstateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SystemFieldKind.ts b/sdk/typescript/lib/generated/models/SystemFieldKind.ts index 9360b51296..e6895290fd 100644 --- a/sdk/typescript/lib/generated/models/SystemFieldKind.ts +++ b/sdk/typescript/lib/generated/models/SystemFieldKind.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SystemFieldStructure.ts b/sdk/typescript/lib/generated/models/SystemFieldStructure.ts index 7610d167eb..71fd44da0c 100644 --- a/sdk/typescript/lib/generated/models/SystemFieldStructure.ts +++ b/sdk/typescript/lib/generated/models/SystemFieldStructure.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SystemFieldStructureAllOf.ts b/sdk/typescript/lib/generated/models/SystemFieldStructureAllOf.ts index 60da576127..0ff9777044 100644 --- a/sdk/typescript/lib/generated/models/SystemFieldStructureAllOf.ts +++ b/sdk/typescript/lib/generated/models/SystemFieldStructureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SystemSchemaStructure.ts b/sdk/typescript/lib/generated/models/SystemSchemaStructure.ts index 229f0cbc88..924e164a55 100644 --- a/sdk/typescript/lib/generated/models/SystemSchemaStructure.ts +++ b/sdk/typescript/lib/generated/models/SystemSchemaStructure.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SystemSchemaStructureAllOf.ts b/sdk/typescript/lib/generated/models/SystemSchemaStructureAllOf.ts index 41dc716f9b..9ea65a20f7 100644 --- a/sdk/typescript/lib/generated/models/SystemSchemaStructureAllOf.ts +++ b/sdk/typescript/lib/generated/models/SystemSchemaStructureAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/SystemTransaction.ts b/sdk/typescript/lib/generated/models/SystemTransaction.ts index 47ad32720e..f8721e4811 100644 --- a/sdk/typescript/lib/generated/models/SystemTransaction.ts +++ b/sdk/typescript/lib/generated/models/SystemTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TargetIdentifier.ts b/sdk/typescript/lib/generated/models/TargetIdentifier.ts index e959e6f8d8..cdfda7497b 100644 --- a/sdk/typescript/lib/generated/models/TargetIdentifier.ts +++ b/sdk/typescript/lib/generated/models/TargetIdentifier.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TargetIdentifierBase.ts b/sdk/typescript/lib/generated/models/TargetIdentifierBase.ts index f6fd701b5f..9f8daa1b81 100644 --- a/sdk/typescript/lib/generated/models/TargetIdentifierBase.ts +++ b/sdk/typescript/lib/generated/models/TargetIdentifierBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TargetIdentifierType.ts b/sdk/typescript/lib/generated/models/TargetIdentifierType.ts index bfc63da489..8504628be3 100644 --- a/sdk/typescript/lib/generated/models/TargetIdentifierType.ts +++ b/sdk/typescript/lib/generated/models/TargetIdentifierType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TimestampedValidatorSignature.ts b/sdk/typescript/lib/generated/models/TimestampedValidatorSignature.ts index 4767b16ffc..0a38c7b0fa 100644 --- a/sdk/typescript/lib/generated/models/TimestampedValidatorSignature.ts +++ b/sdk/typescript/lib/generated/models/TimestampedValidatorSignature.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionCallPreviewRequest.ts b/sdk/typescript/lib/generated/models/TransactionCallPreviewRequest.ts index 3ef9301dcd..4b57235309 100644 --- a/sdk/typescript/lib/generated/models/TransactionCallPreviewRequest.ts +++ b/sdk/typescript/lib/generated/models/TransactionCallPreviewRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionCallPreviewResponse.ts b/sdk/typescript/lib/generated/models/TransactionCallPreviewResponse.ts index 29bb91a0fa..f1c739b413 100644 --- a/sdk/typescript/lib/generated/models/TransactionCallPreviewResponse.ts +++ b/sdk/typescript/lib/generated/models/TransactionCallPreviewResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionFormatOptions.ts b/sdk/typescript/lib/generated/models/TransactionFormatOptions.ts index 5d80ad85ac..c39c519692 100644 --- a/sdk/typescript/lib/generated/models/TransactionFormatOptions.ts +++ b/sdk/typescript/lib/generated/models/TransactionFormatOptions.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionHeader.ts b/sdk/typescript/lib/generated/models/TransactionHeader.ts index 5bf15f321b..70b612be70 100644 --- a/sdk/typescript/lib/generated/models/TransactionHeader.ts +++ b/sdk/typescript/lib/generated/models/TransactionHeader.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionIdKey.ts b/sdk/typescript/lib/generated/models/TransactionIdKey.ts index 6cfa42a837..e744096fa9 100644 --- a/sdk/typescript/lib/generated/models/TransactionIdKey.ts +++ b/sdk/typescript/lib/generated/models/TransactionIdKey.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionIdentifiers.ts b/sdk/typescript/lib/generated/models/TransactionIdentifiers.ts index d91e1d0d70..32c3da29aa 100644 --- a/sdk/typescript/lib/generated/models/TransactionIdentifiers.ts +++ b/sdk/typescript/lib/generated/models/TransactionIdentifiers.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionIntent.ts b/sdk/typescript/lib/generated/models/TransactionIntent.ts index 95d3c93c9c..5861613c28 100644 --- a/sdk/typescript/lib/generated/models/TransactionIntent.ts +++ b/sdk/typescript/lib/generated/models/TransactionIntent.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionIntentStatus.ts b/sdk/typescript/lib/generated/models/TransactionIntentStatus.ts index 89a3e4b6b8..a9783e41ef 100644 --- a/sdk/typescript/lib/generated/models/TransactionIntentStatus.ts +++ b/sdk/typescript/lib/generated/models/TransactionIntentStatus.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionMessage.ts b/sdk/typescript/lib/generated/models/TransactionMessage.ts index 2ffddc1cc2..9f2699e68a 100644 --- a/sdk/typescript/lib/generated/models/TransactionMessage.ts +++ b/sdk/typescript/lib/generated/models/TransactionMessage.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionMessageBase.ts b/sdk/typescript/lib/generated/models/TransactionMessageBase.ts index 3449511642..9d8bdbd15d 100644 --- a/sdk/typescript/lib/generated/models/TransactionMessageBase.ts +++ b/sdk/typescript/lib/generated/models/TransactionMessageBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionMessageType.ts b/sdk/typescript/lib/generated/models/TransactionMessageType.ts index 2e2296a5c9..d51f38c61b 100644 --- a/sdk/typescript/lib/generated/models/TransactionMessageType.ts +++ b/sdk/typescript/lib/generated/models/TransactionMessageType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionParseRequest.ts b/sdk/typescript/lib/generated/models/TransactionParseRequest.ts index e1bf6d8bd3..5a0fe96428 100644 --- a/sdk/typescript/lib/generated/models/TransactionParseRequest.ts +++ b/sdk/typescript/lib/generated/models/TransactionParseRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionParseResponse.ts b/sdk/typescript/lib/generated/models/TransactionParseResponse.ts index 1be24deb8d..dd2dacfa9f 100644 --- a/sdk/typescript/lib/generated/models/TransactionParseResponse.ts +++ b/sdk/typescript/lib/generated/models/TransactionParseResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionPayloadDetails.ts b/sdk/typescript/lib/generated/models/TransactionPayloadDetails.ts index 7fe5816cfd..1798642d42 100644 --- a/sdk/typescript/lib/generated/models/TransactionPayloadDetails.ts +++ b/sdk/typescript/lib/generated/models/TransactionPayloadDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionPayloadStatus.ts b/sdk/typescript/lib/generated/models/TransactionPayloadStatus.ts index 7db8d4c6c5..0965950165 100644 --- a/sdk/typescript/lib/generated/models/TransactionPayloadStatus.ts +++ b/sdk/typescript/lib/generated/models/TransactionPayloadStatus.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionPreviewRequest.ts b/sdk/typescript/lib/generated/models/TransactionPreviewRequest.ts index 3afd1274da..8cfdefd28d 100644 --- a/sdk/typescript/lib/generated/models/TransactionPreviewRequest.ts +++ b/sdk/typescript/lib/generated/models/TransactionPreviewRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionPreviewRequestFlags.ts b/sdk/typescript/lib/generated/models/TransactionPreviewRequestFlags.ts index b54da5f6ab..8f033b2997 100644 --- a/sdk/typescript/lib/generated/models/TransactionPreviewRequestFlags.ts +++ b/sdk/typescript/lib/generated/models/TransactionPreviewRequestFlags.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionPreviewResponse.ts b/sdk/typescript/lib/generated/models/TransactionPreviewResponse.ts index 1dc73633a8..d1fecb50df 100644 --- a/sdk/typescript/lib/generated/models/TransactionPreviewResponse.ts +++ b/sdk/typescript/lib/generated/models/TransactionPreviewResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionPreviewResponseLogsInner.ts b/sdk/typescript/lib/generated/models/TransactionPreviewResponseLogsInner.ts index 23935a9fe0..9507f9c912 100644 --- a/sdk/typescript/lib/generated/models/TransactionPreviewResponseLogsInner.ts +++ b/sdk/typescript/lib/generated/models/TransactionPreviewResponseLogsInner.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionReceipt.ts b/sdk/typescript/lib/generated/models/TransactionReceipt.ts index 58de7f5f79..fa19dd4a5b 100644 --- a/sdk/typescript/lib/generated/models/TransactionReceipt.ts +++ b/sdk/typescript/lib/generated/models/TransactionReceipt.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionReceiptRequest.ts b/sdk/typescript/lib/generated/models/TransactionReceiptRequest.ts index dce190a33d..1574de0362 100644 --- a/sdk/typescript/lib/generated/models/TransactionReceiptRequest.ts +++ b/sdk/typescript/lib/generated/models/TransactionReceiptRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionReceiptResponse.ts b/sdk/typescript/lib/generated/models/TransactionReceiptResponse.ts index 39a03ce3c0..45272681e0 100644 --- a/sdk/typescript/lib/generated/models/TransactionReceiptResponse.ts +++ b/sdk/typescript/lib/generated/models/TransactionReceiptResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionStatus.ts b/sdk/typescript/lib/generated/models/TransactionStatus.ts index 909ac9680b..45a4548fe1 100644 --- a/sdk/typescript/lib/generated/models/TransactionStatus.ts +++ b/sdk/typescript/lib/generated/models/TransactionStatus.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionStatusRequest.ts b/sdk/typescript/lib/generated/models/TransactionStatusRequest.ts index 629d15ee92..3e730404d4 100644 --- a/sdk/typescript/lib/generated/models/TransactionStatusRequest.ts +++ b/sdk/typescript/lib/generated/models/TransactionStatusRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionStatusResponse.ts b/sdk/typescript/lib/generated/models/TransactionStatusResponse.ts index 3a2f92bf9f..650e8c527f 100644 --- a/sdk/typescript/lib/generated/models/TransactionStatusResponse.ts +++ b/sdk/typescript/lib/generated/models/TransactionStatusResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetails.ts b/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetails.ts index 3d55b38601..822631e5e7 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetails.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetailsBase.ts b/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetailsBase.ts index f4312e55e3..95cd0af3b0 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetailsBase.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetailsBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetailsType.ts b/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetailsType.ts index f70dbb53e4..b99051288a 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetailsType.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitErrorDetailsType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitErrorResponse.ts b/sdk/typescript/lib/generated/models/TransactionSubmitErrorResponse.ts index 38ad84a90c..49f1f58d0c 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitErrorResponse.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitErrorResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitErrorResponseAllOf.ts b/sdk/typescript/lib/generated/models/TransactionSubmitErrorResponseAllOf.ts index 9b27ecc5be..48419ccca7 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitErrorResponseAllOf.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitErrorResponseAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitIntentAlreadyCommitted.ts b/sdk/typescript/lib/generated/models/TransactionSubmitIntentAlreadyCommitted.ts index 01a609ccdf..e5aad624c8 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitIntentAlreadyCommitted.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitIntentAlreadyCommitted.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitPriorityThresholdNotMetErrorDetails.ts b/sdk/typescript/lib/generated/models/TransactionSubmitPriorityThresholdNotMetErrorDetails.ts index 2ee534d00c..0c23b0aeb2 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitPriorityThresholdNotMetErrorDetails.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitPriorityThresholdNotMetErrorDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitRejectedErrorDetails.ts b/sdk/typescript/lib/generated/models/TransactionSubmitRejectedErrorDetails.ts index 021fe5058e..cc89df9327 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitRejectedErrorDetails.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitRejectedErrorDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitRequest.ts b/sdk/typescript/lib/generated/models/TransactionSubmitRequest.ts index 4fe59219e9..0c687b8806 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitRequest.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionSubmitResponse.ts b/sdk/typescript/lib/generated/models/TransactionSubmitResponse.ts index 06ab14b425..582dcab5b1 100644 --- a/sdk/typescript/lib/generated/models/TransactionSubmitResponse.ts +++ b/sdk/typescript/lib/generated/models/TransactionSubmitResponse.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntrySubstate.ts b/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntrySubstate.ts index 76c7745951..c709e49812 100644 --- a/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntrySubstate.ts +++ b/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntrySubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntrySubstateAllOf.ts b/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntrySubstateAllOf.ts index 11f933acf4..923411c44e 100644 --- a/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntrySubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntrySubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntryValue.ts b/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntryValue.ts index 00d46f47a8..6819df2c41 100644 --- a/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntryValue.ts +++ b/sdk/typescript/lib/generated/models/TransactionTrackerCollectionEntryValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateSubstate.ts index 5fc61e377a..1599a37b33 100644 --- a/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateSubstateAllOf.ts index 8c62d564e3..a3273da991 100644 --- a/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateValue.ts b/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateValue.ts index 54f37bce67..d716659646 100644 --- a/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/TransactionTrackerFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TransactionTrackerTransactionStatus.ts b/sdk/typescript/lib/generated/models/TransactionTrackerTransactionStatus.ts index ec615c85e4..be3ed8a2a4 100644 --- a/sdk/typescript/lib/generated/models/TransactionTrackerTransactionStatus.ts +++ b/sdk/typescript/lib/generated/models/TransactionTrackerTransactionStatus.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateSubstate.ts index 9253ed7685..0ec640be36 100644 --- a/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateSubstateAllOf.ts index 4bccd5e4fe..8d7805ac61 100644 --- a/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateValue.ts b/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateValue.ts index 63df238e4e..4e9ac4e3a4 100644 --- a/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/TwoResourcePoolFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TypeInfoDetails.ts b/sdk/typescript/lib/generated/models/TypeInfoDetails.ts index f30833204a..4ac9112594 100644 --- a/sdk/typescript/lib/generated/models/TypeInfoDetails.ts +++ b/sdk/typescript/lib/generated/models/TypeInfoDetails.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TypeInfoDetailsBase.ts b/sdk/typescript/lib/generated/models/TypeInfoDetailsBase.ts index c6396bad57..590f70948e 100644 --- a/sdk/typescript/lib/generated/models/TypeInfoDetailsBase.ts +++ b/sdk/typescript/lib/generated/models/TypeInfoDetailsBase.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoSubstate.ts b/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoSubstate.ts index 6bdcd64363..d0928e95f6 100644 --- a/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoSubstate.ts +++ b/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoSubstateAllOf.ts b/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoSubstateAllOf.ts index 3a78be89b0..47dcc737c6 100644 --- a/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoValue.ts b/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoValue.ts index a0f2cf9982..31b2ddae05 100644 --- a/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoValue.ts +++ b/sdk/typescript/lib/generated/models/TypeInfoModuleFieldTypeInfoValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/TypeInfoType.ts b/sdk/typescript/lib/generated/models/TypeInfoType.ts index b7c675ab83..2448e3d44c 100644 --- a/sdk/typescript/lib/generated/models/TypeInfoType.ts +++ b/sdk/typescript/lib/generated/models/TypeInfoType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/UpdatedSubstate.ts b/sdk/typescript/lib/generated/models/UpdatedSubstate.ts index 2a8f3bd40f..a55dacc8b7 100644 --- a/sdk/typescript/lib/generated/models/UpdatedSubstate.ts +++ b/sdk/typescript/lib/generated/models/UpdatedSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/UserLedgerTransaction.ts b/sdk/typescript/lib/generated/models/UserLedgerTransaction.ts index ec5a993345..648a1d2f8e 100644 --- a/sdk/typescript/lib/generated/models/UserLedgerTransaction.ts +++ b/sdk/typescript/lib/generated/models/UserLedgerTransaction.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/UserLedgerTransactionAllOf.ts b/sdk/typescript/lib/generated/models/UserLedgerTransactionAllOf.ts index 86d9fb6027..31eb3e1aea 100644 --- a/sdk/typescript/lib/generated/models/UserLedgerTransactionAllOf.ts +++ b/sdk/typescript/lib/generated/models/UserLedgerTransactionAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ValidatorFeeChangeRequest.ts b/sdk/typescript/lib/generated/models/ValidatorFeeChangeRequest.ts index 005c1121d9..4bdf52702c 100644 --- a/sdk/typescript/lib/generated/models/ValidatorFeeChangeRequest.ts +++ b/sdk/typescript/lib/generated/models/ValidatorFeeChangeRequest.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstate.ts b/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstate.ts index 552995b105..145962c862 100644 --- a/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstate.ts +++ b/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstateAllOf.ts b/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstateAllOf.ts index 6a10925f47..8e295b0f5f 100644 --- a/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalValue.ts b/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalValue.ts index 71ab677b09..7235023b3f 100644 --- a/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalValue.ts +++ b/sdk/typescript/lib/generated/models/ValidatorFieldProtocolUpdateReadinessSignalValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ValidatorFieldStateSubstate.ts b/sdk/typescript/lib/generated/models/ValidatorFieldStateSubstate.ts index 4f457a7d2a..0696fbf062 100644 --- a/sdk/typescript/lib/generated/models/ValidatorFieldStateSubstate.ts +++ b/sdk/typescript/lib/generated/models/ValidatorFieldStateSubstate.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ValidatorFieldStateSubstateAllOf.ts b/sdk/typescript/lib/generated/models/ValidatorFieldStateSubstateAllOf.ts index 36214b740b..3c56299373 100644 --- a/sdk/typescript/lib/generated/models/ValidatorFieldStateSubstateAllOf.ts +++ b/sdk/typescript/lib/generated/models/ValidatorFieldStateSubstateAllOf.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/ValidatorFieldStateValue.ts b/sdk/typescript/lib/generated/models/ValidatorFieldStateValue.ts index e115ef2754..0efb57c81c 100644 --- a/sdk/typescript/lib/generated/models/ValidatorFieldStateValue.ts +++ b/sdk/typescript/lib/generated/models/ValidatorFieldStateValue.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/VaultBalance.ts b/sdk/typescript/lib/generated/models/VaultBalance.ts index 13e509c755..e4466cf189 100644 --- a/sdk/typescript/lib/generated/models/VaultBalance.ts +++ b/sdk/typescript/lib/generated/models/VaultBalance.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/VirtualLazyLoadSchema.ts b/sdk/typescript/lib/generated/models/VirtualLazyLoadSchema.ts index 4efbe8a060..ad78724dd9 100644 --- a/sdk/typescript/lib/generated/models/VirtualLazyLoadSchema.ts +++ b/sdk/typescript/lib/generated/models/VirtualLazyLoadSchema.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/models/VmType.ts b/sdk/typescript/lib/generated/models/VmType.ts index 38a6ad5638..09271d93b4 100644 --- a/sdk/typescript/lib/generated/models/VmType.ts +++ b/sdk/typescript/lib/generated/models/VmType.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/sdk/typescript/lib/generated/runtime.ts b/sdk/typescript/lib/generated/runtime.ts index 1c1c1cde96..9bdf0511b4 100644 --- a/sdk/typescript/lib/generated/runtime.ts +++ b/sdk/typescript/lib/generated/runtime.ts @@ -1,10 +1,10 @@ /* tslint:disable */ /* eslint-disable */ /** - * Radix Core API - Babylon + * Radix Core API - Babylon (Anemone) * This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node. The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node\'s function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is `api.core.flags.enable_unbounded_endpoints` / `RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS`. This API exposes queries against the node\'s current state (see `/lts/state/` or `/state/`), and streams of transaction history (under `/lts/stream/` or `/stream`). If you require queries against snapshots of historical ledger state, you may also wish to consider using the [Gateway API](https://docs-babylon.radixdlt.com/). ## Integration and forward compatibility guarantees Integrators (such as exchanges) are recommended to use the `/lts/` endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts. All endpoints under `/lts/` have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code. Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes. All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects. * - * The version of the OpenAPI document: v1.0.4 + * The version of the OpenAPI document: v1.1.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).