diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_bool_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_bool_reducer.rs new file mode 100644 index 00000000000..7348fbb73b0 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_bool_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneBoolArgs { + pub b: bool, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneBoolArgs) -> Self { + Self::DeleteAllOneBool { b: args.b } + } +} + +impl __sdk::InModule for DeleteAllOneBoolArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_bool`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_bool { + /// Request that the remote module invoke the reducer `delete_all_one_bool` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_bool:delete_all_one_bool_then`] to run a callback after the reducer completes. + fn delete_all_one_bool(&self, b: bool) -> __sdk::Result<()> { + self.delete_all_one_bool_then(b, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_bool` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_bool_then( + &self, + b: bool, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_bool for super::RemoteReducers { + fn delete_all_one_bool_then( + &self, + b: bool, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneBoolArgs { b }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_byte_struct_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_byte_struct_reducer.rs new file mode 100644 index 00000000000..1cb2d71379c --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_byte_struct_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::byte_struct_type::ByteStruct; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneByteStructArgs { + pub s: ByteStruct, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneByteStructArgs) -> Self { + Self::DeleteAllOneByteStruct { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllOneByteStructArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_byte_struct`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_byte_struct { + /// Request that the remote module invoke the reducer `delete_all_one_byte_struct` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_byte_struct:delete_all_one_byte_struct_then`] to run a callback after the reducer completes. + fn delete_all_one_byte_struct(&self, s: ByteStruct) -> __sdk::Result<()> { + self.delete_all_one_byte_struct_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_byte_struct` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_byte_struct_then( + &self, + s: ByteStruct, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_byte_struct for super::RemoteReducers { + fn delete_all_one_byte_struct_then( + &self, + s: ByteStruct, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneByteStructArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_enum_with_payload_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_enum_with_payload_reducer.rs new file mode 100644 index 00000000000..7ed4405b01c --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_enum_with_payload_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::enum_with_payload_type::EnumWithPayload; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneEnumWithPayloadArgs { + pub e: EnumWithPayload, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneEnumWithPayloadArgs) -> Self { + Self::DeleteAllOneEnumWithPayload { e: args.e } + } +} + +impl __sdk::InModule for DeleteAllOneEnumWithPayloadArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_enum_with_payload`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_enum_with_payload { + /// Request that the remote module invoke the reducer `delete_all_one_enum_with_payload` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_enum_with_payload:delete_all_one_enum_with_payload_then`] to run a callback after the reducer completes. + fn delete_all_one_enum_with_payload(&self, e: EnumWithPayload) -> __sdk::Result<()> { + self.delete_all_one_enum_with_payload_then(e, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_enum_with_payload` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_enum_with_payload_then( + &self, + e: EnumWithPayload, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_enum_with_payload for super::RemoteReducers { + fn delete_all_one_enum_with_payload_then( + &self, + e: EnumWithPayload, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneEnumWithPayloadArgs { e }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_every_primitive_struct_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_every_primitive_struct_reducer.rs new file mode 100644 index 00000000000..d2687a68e86 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_every_primitive_struct_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::every_primitive_struct_type::EveryPrimitiveStruct; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneEveryPrimitiveStructArgs { + pub s: EveryPrimitiveStruct, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneEveryPrimitiveStructArgs) -> Self { + Self::DeleteAllOneEveryPrimitiveStruct { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllOneEveryPrimitiveStructArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_every_primitive_struct`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_every_primitive_struct { + /// Request that the remote module invoke the reducer `delete_all_one_every_primitive_struct` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_every_primitive_struct:delete_all_one_every_primitive_struct_then`] to run a callback after the reducer completes. + fn delete_all_one_every_primitive_struct(&self, s: EveryPrimitiveStruct) -> __sdk::Result<()> { + self.delete_all_one_every_primitive_struct_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_every_primitive_struct` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_every_primitive_struct_then( + &self, + s: EveryPrimitiveStruct, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_every_primitive_struct for super::RemoteReducers { + fn delete_all_one_every_primitive_struct_then( + &self, + s: EveryPrimitiveStruct, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneEveryPrimitiveStructArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_every_vec_struct_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_every_vec_struct_reducer.rs new file mode 100644 index 00000000000..6e4c5e81cfb --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_every_vec_struct_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::every_vec_struct_type::EveryVecStruct; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneEveryVecStructArgs { + pub s: EveryVecStruct, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneEveryVecStructArgs) -> Self { + Self::DeleteAllOneEveryVecStruct { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllOneEveryVecStructArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_every_vec_struct`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_every_vec_struct { + /// Request that the remote module invoke the reducer `delete_all_one_every_vec_struct` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_every_vec_struct:delete_all_one_every_vec_struct_then`] to run a callback after the reducer completes. + fn delete_all_one_every_vec_struct(&self, s: EveryVecStruct) -> __sdk::Result<()> { + self.delete_all_one_every_vec_struct_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_every_vec_struct` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_every_vec_struct_then( + &self, + s: EveryVecStruct, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_every_vec_struct for super::RemoteReducers { + fn delete_all_one_every_vec_struct_then( + &self, + s: EveryVecStruct, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneEveryVecStructArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_f_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_f_32_reducer.rs new file mode 100644 index 00000000000..134d2d89a28 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_f_32_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneF32Args { + pub f: f32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneF32Args) -> Self { + Self::DeleteAllOneF32 { f: args.f } + } +} + +impl __sdk::InModule for DeleteAllOneF32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_f_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_f_32 { + /// Request that the remote module invoke the reducer `delete_all_one_f_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_f_32:delete_all_one_f_32_then`] to run a callback after the reducer completes. + fn delete_all_one_f_32(&self, f: f32) -> __sdk::Result<()> { + self.delete_all_one_f_32_then(f, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_f_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_f_32_then( + &self, + f: f32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_f_32 for super::RemoteReducers { + fn delete_all_one_f_32_then( + &self, + f: f32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneF32Args { f }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_f_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_f_64_reducer.rs new file mode 100644 index 00000000000..ef173149ae3 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_f_64_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneF64Args { + pub f: f64, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneF64Args) -> Self { + Self::DeleteAllOneF64 { f: args.f } + } +} + +impl __sdk::InModule for DeleteAllOneF64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_f_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_f_64 { + /// Request that the remote module invoke the reducer `delete_all_one_f_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_f_64:delete_all_one_f_64_then`] to run a callback after the reducer completes. + fn delete_all_one_f_64(&self, f: f64) -> __sdk::Result<()> { + self.delete_all_one_f_64_then(f, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_f_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_f_64_then( + &self, + f: f64, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_f_64 for super::RemoteReducers { + fn delete_all_one_f_64_then( + &self, + f: f64, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneF64Args { f }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_128_reducer.rs new file mode 100644 index 00000000000..833fc240a3f --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_128_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneI128Args { + pub n: i128, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneI128Args) -> Self { + Self::DeleteAllOneI128 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneI128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_i_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_i_128 { + /// Request that the remote module invoke the reducer `delete_all_one_i_128` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_i_128:delete_all_one_i_128_then`] to run a callback after the reducer completes. + fn delete_all_one_i_128(&self, n: i128) -> __sdk::Result<()> { + self.delete_all_one_i_128_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_i_128` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_i_128_then( + &self, + n: i128, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_i_128 for super::RemoteReducers { + fn delete_all_one_i_128_then( + &self, + n: i128, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneI128Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_16_reducer.rs new file mode 100644 index 00000000000..b6ca9a0c481 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_16_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneI16Args { + pub n: i16, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneI16Args) -> Self { + Self::DeleteAllOneI16 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneI16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_i_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_i_16 { + /// Request that the remote module invoke the reducer `delete_all_one_i_16` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_i_16:delete_all_one_i_16_then`] to run a callback after the reducer completes. + fn delete_all_one_i_16(&self, n: i16) -> __sdk::Result<()> { + self.delete_all_one_i_16_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_i_16` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_i_16_then( + &self, + n: i16, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_i_16 for super::RemoteReducers { + fn delete_all_one_i_16_then( + &self, + n: i16, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneI16Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_256_reducer.rs new file mode 100644 index 00000000000..f13bff56c6c --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_256_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneI256Args { + pub n: __sats::i256, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneI256Args) -> Self { + Self::DeleteAllOneI256 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneI256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_i_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_i_256 { + /// Request that the remote module invoke the reducer `delete_all_one_i_256` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_i_256:delete_all_one_i_256_then`] to run a callback after the reducer completes. + fn delete_all_one_i_256(&self, n: __sats::i256) -> __sdk::Result<()> { + self.delete_all_one_i_256_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_i_256` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_i_256_then( + &self, + n: __sats::i256, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_i_256 for super::RemoteReducers { + fn delete_all_one_i_256_then( + &self, + n: __sats::i256, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneI256Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_32_reducer.rs new file mode 100644 index 00000000000..602f712b40c --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_32_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneI32Args { + pub n: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneI32Args) -> Self { + Self::DeleteAllOneI32 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_i_32 { + /// Request that the remote module invoke the reducer `delete_all_one_i_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_i_32:delete_all_one_i_32_then`] to run a callback after the reducer completes. + fn delete_all_one_i_32(&self, n: i32) -> __sdk::Result<()> { + self.delete_all_one_i_32_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_i_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_i_32_then( + &self, + n: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_i_32 for super::RemoteReducers { + fn delete_all_one_i_32_then( + &self, + n: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneI32Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_64_reducer.rs new file mode 100644 index 00000000000..ae705cee60b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_64_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneI64Args { + pub n: i64, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneI64Args) -> Self { + Self::DeleteAllOneI64 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneI64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_i_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_i_64 { + /// Request that the remote module invoke the reducer `delete_all_one_i_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_i_64:delete_all_one_i_64_then`] to run a callback after the reducer completes. + fn delete_all_one_i_64(&self, n: i64) -> __sdk::Result<()> { + self.delete_all_one_i_64_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_i_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_i_64_then( + &self, + n: i64, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_i_64 for super::RemoteReducers { + fn delete_all_one_i_64_then( + &self, + n: i64, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneI64Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_8_reducer.rs new file mode 100644 index 00000000000..6abd81c7838 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_i_8_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneI8Args { + pub n: i8, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneI8Args) -> Self { + Self::DeleteAllOneI8 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneI8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_i_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_i_8 { + /// Request that the remote module invoke the reducer `delete_all_one_i_8` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_i_8:delete_all_one_i_8_then`] to run a callback after the reducer completes. + fn delete_all_one_i_8(&self, n: i8) -> __sdk::Result<()> { + self.delete_all_one_i_8_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_i_8` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_i_8_then( + &self, + n: i8, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_i_8 for super::RemoteReducers { + fn delete_all_one_i_8_then( + &self, + n: i8, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneI8Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_identity_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_identity_reducer.rs new file mode 100644 index 00000000000..dc89ea2d013 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_identity_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneIdentityArgs { + pub i: __sdk::Identity, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneIdentityArgs) -> Self { + Self::DeleteAllOneIdentity { i: args.i } + } +} + +impl __sdk::InModule for DeleteAllOneIdentityArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_identity`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_identity { + /// Request that the remote module invoke the reducer `delete_all_one_identity` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_identity:delete_all_one_identity_then`] to run a callback after the reducer completes. + fn delete_all_one_identity(&self, i: __sdk::Identity) -> __sdk::Result<()> { + self.delete_all_one_identity_then(i, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_identity` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_identity_then( + &self, + i: __sdk::Identity, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_identity for super::RemoteReducers { + fn delete_all_one_identity_then( + &self, + i: __sdk::Identity, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneIdentityArgs { i }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_simple_enum_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_simple_enum_reducer.rs new file mode 100644 index 00000000000..0f5756387f4 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_simple_enum_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::simple_enum_type::SimpleEnum; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneSimpleEnumArgs { + pub e: SimpleEnum, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneSimpleEnumArgs) -> Self { + Self::DeleteAllOneSimpleEnum { e: args.e } + } +} + +impl __sdk::InModule for DeleteAllOneSimpleEnumArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_simple_enum`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_simple_enum { + /// Request that the remote module invoke the reducer `delete_all_one_simple_enum` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_simple_enum:delete_all_one_simple_enum_then`] to run a callback after the reducer completes. + fn delete_all_one_simple_enum(&self, e: SimpleEnum) -> __sdk::Result<()> { + self.delete_all_one_simple_enum_then(e, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_simple_enum` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_simple_enum_then( + &self, + e: SimpleEnum, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_simple_enum for super::RemoteReducers { + fn delete_all_one_simple_enum_then( + &self, + e: SimpleEnum, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneSimpleEnumArgs { e }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_string_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_string_reducer.rs new file mode 100644 index 00000000000..ae35abad618 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_string_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneStringArgs { + pub s: String, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneStringArgs) -> Self { + Self::DeleteAllOneString { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllOneStringArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_string`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_string { + /// Request that the remote module invoke the reducer `delete_all_one_string` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_string:delete_all_one_string_then`] to run a callback after the reducer completes. + fn delete_all_one_string(&self, s: String) -> __sdk::Result<()> { + self.delete_all_one_string_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_string` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_string_then( + &self, + s: String, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_string for super::RemoteReducers { + fn delete_all_one_string_then( + &self, + s: String, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneStringArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_timestamp_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_timestamp_reducer.rs new file mode 100644 index 00000000000..ab862d8ae9a --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_timestamp_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneTimestampArgs { + pub t: __sdk::Timestamp, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneTimestampArgs) -> Self { + Self::DeleteAllOneTimestamp { t: args.t } + } +} + +impl __sdk::InModule for DeleteAllOneTimestampArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_timestamp`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_timestamp { + /// Request that the remote module invoke the reducer `delete_all_one_timestamp` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_timestamp:delete_all_one_timestamp_then`] to run a callback after the reducer completes. + fn delete_all_one_timestamp(&self, t: __sdk::Timestamp) -> __sdk::Result<()> { + self.delete_all_one_timestamp_then(t, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_timestamp` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_timestamp_then( + &self, + t: __sdk::Timestamp, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_timestamp for super::RemoteReducers { + fn delete_all_one_timestamp_then( + &self, + t: __sdk::Timestamp, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneTimestampArgs { t }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_128_reducer.rs new file mode 100644 index 00000000000..1fc95a7d228 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_128_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneU128Args { + pub n: u128, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneU128Args) -> Self { + Self::DeleteAllOneU128 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneU128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_u_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_u_128 { + /// Request that the remote module invoke the reducer `delete_all_one_u_128` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_u_128:delete_all_one_u_128_then`] to run a callback after the reducer completes. + fn delete_all_one_u_128(&self, n: u128) -> __sdk::Result<()> { + self.delete_all_one_u_128_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_u_128` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_u_128_then( + &self, + n: u128, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_u_128 for super::RemoteReducers { + fn delete_all_one_u_128_then( + &self, + n: u128, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneU128Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_16_reducer.rs new file mode 100644 index 00000000000..9f112adb3ab --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_16_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneU16Args { + pub n: u16, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneU16Args) -> Self { + Self::DeleteAllOneU16 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneU16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_u_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_u_16 { + /// Request that the remote module invoke the reducer `delete_all_one_u_16` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_u_16:delete_all_one_u_16_then`] to run a callback after the reducer completes. + fn delete_all_one_u_16(&self, n: u16) -> __sdk::Result<()> { + self.delete_all_one_u_16_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_u_16` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_u_16_then( + &self, + n: u16, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_u_16 for super::RemoteReducers { + fn delete_all_one_u_16_then( + &self, + n: u16, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneU16Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_256_reducer.rs new file mode 100644 index 00000000000..5ee154e3594 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_256_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneU256Args { + pub n: __sats::u256, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneU256Args) -> Self { + Self::DeleteAllOneU256 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneU256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_u_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_u_256 { + /// Request that the remote module invoke the reducer `delete_all_one_u_256` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_u_256:delete_all_one_u_256_then`] to run a callback after the reducer completes. + fn delete_all_one_u_256(&self, n: __sats::u256) -> __sdk::Result<()> { + self.delete_all_one_u_256_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_u_256` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_u_256_then( + &self, + n: __sats::u256, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_u_256 for super::RemoteReducers { + fn delete_all_one_u_256_then( + &self, + n: __sats::u256, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneU256Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_32_reducer.rs new file mode 100644 index 00000000000..710d0fe11ac --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_32_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneU32Args { + pub n: u32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneU32Args) -> Self { + Self::DeleteAllOneU32 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneU32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_u_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_u_32 { + /// Request that the remote module invoke the reducer `delete_all_one_u_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_u_32:delete_all_one_u_32_then`] to run a callback after the reducer completes. + fn delete_all_one_u_32(&self, n: u32) -> __sdk::Result<()> { + self.delete_all_one_u_32_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_u_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_u_32_then( + &self, + n: u32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_u_32 for super::RemoteReducers { + fn delete_all_one_u_32_then( + &self, + n: u32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneU32Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_64_reducer.rs new file mode 100644 index 00000000000..af5850fab3f --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_64_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneU64Args { + pub n: u64, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneU64Args) -> Self { + Self::DeleteAllOneU64 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneU64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_u_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_u_64 { + /// Request that the remote module invoke the reducer `delete_all_one_u_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_u_64:delete_all_one_u_64_then`] to run a callback after the reducer completes. + fn delete_all_one_u_64(&self, n: u64) -> __sdk::Result<()> { + self.delete_all_one_u_64_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_u_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_u_64_then( + &self, + n: u64, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_u_64 for super::RemoteReducers { + fn delete_all_one_u_64_then( + &self, + n: u64, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneU64Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_8_reducer.rs new file mode 100644 index 00000000000..f924091f1d5 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_u_8_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneU8Args { + pub n: u8, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneU8Args) -> Self { + Self::DeleteAllOneU8 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOneU8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_u_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_u_8 { + /// Request that the remote module invoke the reducer `delete_all_one_u_8` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_u_8:delete_all_one_u_8_then`] to run a callback after the reducer completes. + fn delete_all_one_u_8(&self, n: u8) -> __sdk::Result<()> { + self.delete_all_one_u_8_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_u_8` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_u_8_then( + &self, + n: u8, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_u_8 for super::RemoteReducers { + fn delete_all_one_u_8_then( + &self, + n: u8, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneU8Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_unit_struct_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_unit_struct_reducer.rs new file mode 100644 index 00000000000..f506b7f9ee1 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_unit_struct_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::unit_struct_type::UnitStruct; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneUnitStructArgs { + pub s: UnitStruct, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneUnitStructArgs) -> Self { + Self::DeleteAllOneUnitStruct { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllOneUnitStructArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_unit_struct`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_unit_struct { + /// Request that the remote module invoke the reducer `delete_all_one_unit_struct` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_unit_struct:delete_all_one_unit_struct_then`] to run a callback after the reducer completes. + fn delete_all_one_unit_struct(&self, s: UnitStruct) -> __sdk::Result<()> { + self.delete_all_one_unit_struct_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_unit_struct` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_unit_struct_then( + &self, + s: UnitStruct, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_unit_struct for super::RemoteReducers { + fn delete_all_one_unit_struct_then( + &self, + s: UnitStruct, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneUnitStructArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_uuid_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_uuid_reducer.rs new file mode 100644 index 00000000000..e394ef91d70 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_one_uuid_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOneUuidArgs { + pub u: __sdk::Uuid, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOneUuidArgs) -> Self { + Self::DeleteAllOneUuid { u: args.u } + } +} + +impl __sdk::InModule for DeleteAllOneUuidArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_one_uuid`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_one_uuid { + /// Request that the remote module invoke the reducer `delete_all_one_uuid` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_one_uuid:delete_all_one_uuid_then`] to run a callback after the reducer completes. + fn delete_all_one_uuid(&self, u: __sdk::Uuid) -> __sdk::Result<()> { + self.delete_all_one_uuid_then(u, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_one_uuid` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_one_uuid_then( + &self, + u: __sdk::Uuid, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_one_uuid for super::RemoteReducers { + fn delete_all_one_uuid_then( + &self, + u: __sdk::Uuid, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOneUuidArgs { u }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_every_primitive_struct_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_every_primitive_struct_reducer.rs new file mode 100644 index 00000000000..fb5890975f0 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_every_primitive_struct_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::every_primitive_struct_type::EveryPrimitiveStruct; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOptionEveryPrimitiveStructArgs { + pub s: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOptionEveryPrimitiveStructArgs) -> Self { + Self::DeleteAllOptionEveryPrimitiveStruct { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllOptionEveryPrimitiveStructArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_option_every_primitive_struct`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_option_every_primitive_struct { + /// Request that the remote module invoke the reducer `delete_all_option_every_primitive_struct` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_option_every_primitive_struct:delete_all_option_every_primitive_struct_then`] to run a callback after the reducer completes. + fn delete_all_option_every_primitive_struct(&self, s: Option) -> __sdk::Result<()> { + self.delete_all_option_every_primitive_struct_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_option_every_primitive_struct` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_option_every_primitive_struct_then( + &self, + s: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_option_every_primitive_struct for super::RemoteReducers { + fn delete_all_option_every_primitive_struct_then( + &self, + s: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOptionEveryPrimitiveStructArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/send_scheduled_message_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_i_32_reducer.rs similarity index 57% rename from sdks/rust/tests/test-client/src/module_bindings/send_scheduled_message_reducer.rs rename to sdks/rust/tests/test-client/src/module_bindings/delete_all_option_i_32_reducer.rs index 2c6a5d14efa..5bef2b26a95 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/send_scheduled_message_reducer.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_i_32_reducer.rs @@ -4,48 +4,46 @@ #![allow(unused, clippy::all)] use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; -use super::scheduled_table_type::ScheduledTable; - #[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] #[sats(crate = __lib)] -pub(super) struct SendScheduledMessageArgs { - pub arg: ScheduledTable, +pub(super) struct DeleteAllOptionI32Args { + pub n: Option, } -impl From for super::Reducer { - fn from(args: SendScheduledMessageArgs) -> Self { - Self::SendScheduledMessage { arg: args.arg } +impl From for super::Reducer { + fn from(args: DeleteAllOptionI32Args) -> Self { + Self::DeleteAllOptionI32 { n: args.n } } } -impl __sdk::InModule for SendScheduledMessageArgs { +impl __sdk::InModule for DeleteAllOptionI32Args { type Module = super::RemoteModule; } #[allow(non_camel_case_types)] -/// Extension trait for access to the reducer `send_scheduled_message`. +/// Extension trait for access to the reducer `delete_all_option_i_32`. /// /// Implemented for [`super::RemoteReducers`]. -pub trait send_scheduled_message { - /// Request that the remote module invoke the reducer `send_scheduled_message` to run as soon as possible. +pub trait delete_all_option_i_32 { + /// Request that the remote module invoke the reducer `delete_all_option_i_32` to run as soon as possible. /// /// This method returns immediately, and errors only if we are unable to send the request. /// The reducer will run asynchronously in the future, /// and this method provides no way to listen for its completion status. - /// /// Use [`send_scheduled_message:send_scheduled_message_then`] to run a callback after the reducer completes. - fn send_scheduled_message(&self, arg: ScheduledTable) -> __sdk::Result<()> { - self.send_scheduled_message_then(arg, |_, _| {}) + /// /// Use [`delete_all_option_i_32:delete_all_option_i_32_then`] to run a callback after the reducer completes. + fn delete_all_option_i_32(&self, n: Option) -> __sdk::Result<()> { + self.delete_all_option_i_32_then(n, |_, _| {}) } - /// Request that the remote module invoke the reducer `send_scheduled_message` to run as soon as possible, + /// Request that the remote module invoke the reducer `delete_all_option_i_32` to run as soon as possible, /// registering `callback` to run when we are notified that the reducer completed. /// /// This method returns immediately, and errors only if we are unable to send the request. /// The reducer will run asynchronously in the future, /// and its status can be observed with the `callback`. - fn send_scheduled_message_then( + fn delete_all_option_i_32_then( &self, - arg: ScheduledTable, + n: Option, callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + Send @@ -53,16 +51,16 @@ pub trait send_scheduled_message { ) -> __sdk::Result<()>; } -impl send_scheduled_message for super::RemoteReducers { - fn send_scheduled_message_then( +impl delete_all_option_i_32 for super::RemoteReducers { + fn delete_all_option_i_32_then( &self, - arg: ScheduledTable, + n: Option, callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + Send + 'static, ) -> __sdk::Result<()> { self.imp - .invoke_reducer_with_callback(SendScheduledMessageArgs { arg }, callback) + .invoke_reducer_with_callback(DeleteAllOptionI32Args { n }, callback) } } diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_identity_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_identity_reducer.rs new file mode 100644 index 00000000000..df6013187b2 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_identity_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOptionIdentityArgs { + pub i: Option<__sdk::Identity>, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOptionIdentityArgs) -> Self { + Self::DeleteAllOptionIdentity { i: args.i } + } +} + +impl __sdk::InModule for DeleteAllOptionIdentityArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_option_identity`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_option_identity { + /// Request that the remote module invoke the reducer `delete_all_option_identity` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_option_identity:delete_all_option_identity_then`] to run a callback after the reducer completes. + fn delete_all_option_identity(&self, i: Option<__sdk::Identity>) -> __sdk::Result<()> { + self.delete_all_option_identity_then(i, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_option_identity` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_option_identity_then( + &self, + i: Option<__sdk::Identity>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_option_identity for super::RemoteReducers { + fn delete_all_option_identity_then( + &self, + i: Option<__sdk::Identity>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOptionIdentityArgs { i }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_simple_enum_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_simple_enum_reducer.rs new file mode 100644 index 00000000000..03d0c0a2cba --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_simple_enum_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::simple_enum_type::SimpleEnum; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOptionSimpleEnumArgs { + pub e: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOptionSimpleEnumArgs) -> Self { + Self::DeleteAllOptionSimpleEnum { e: args.e } + } +} + +impl __sdk::InModule for DeleteAllOptionSimpleEnumArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_option_simple_enum`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_option_simple_enum { + /// Request that the remote module invoke the reducer `delete_all_option_simple_enum` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_option_simple_enum:delete_all_option_simple_enum_then`] to run a callback after the reducer completes. + fn delete_all_option_simple_enum(&self, e: Option) -> __sdk::Result<()> { + self.delete_all_option_simple_enum_then(e, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_option_simple_enum` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_option_simple_enum_then( + &self, + e: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_option_simple_enum for super::RemoteReducers { + fn delete_all_option_simple_enum_then( + &self, + e: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOptionSimpleEnumArgs { e }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_string_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_string_reducer.rs new file mode 100644 index 00000000000..a48ae137923 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_string_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOptionStringArgs { + pub s: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOptionStringArgs) -> Self { + Self::DeleteAllOptionString { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllOptionStringArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_option_string`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_option_string { + /// Request that the remote module invoke the reducer `delete_all_option_string` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_option_string:delete_all_option_string_then`] to run a callback after the reducer completes. + fn delete_all_option_string(&self, s: Option) -> __sdk::Result<()> { + self.delete_all_option_string_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_option_string` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_option_string_then( + &self, + s: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_option_string for super::RemoteReducers { + fn delete_all_option_string_then( + &self, + s: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOptionStringArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_uuid_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_uuid_reducer.rs new file mode 100644 index 00000000000..fafc213069c --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_uuid_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOptionUuidArgs { + pub u: Option<__sdk::Uuid>, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOptionUuidArgs) -> Self { + Self::DeleteAllOptionUuid { u: args.u } + } +} + +impl __sdk::InModule for DeleteAllOptionUuidArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_option_uuid`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_option_uuid { + /// Request that the remote module invoke the reducer `delete_all_option_uuid` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_option_uuid:delete_all_option_uuid_then`] to run a callback after the reducer completes. + fn delete_all_option_uuid(&self, u: Option<__sdk::Uuid>) -> __sdk::Result<()> { + self.delete_all_option_uuid_then(u, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_option_uuid` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_option_uuid_then( + &self, + u: Option<__sdk::Uuid>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_option_uuid for super::RemoteReducers { + fn delete_all_option_uuid_then( + &self, + u: Option<__sdk::Uuid>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOptionUuidArgs { u }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_vec_option_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_vec_option_i_32_reducer.rs new file mode 100644 index 00000000000..dc9395700a1 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_vec_option_i_32_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllOptionVecOptionI32Args { + pub v: Option>>, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOptionVecOptionI32Args) -> Self { + Self::DeleteAllOptionVecOptionI32 { v: args.v } + } +} + +impl __sdk::InModule for DeleteAllOptionVecOptionI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_option_vec_option_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_option_vec_option_i_32 { + /// Request that the remote module invoke the reducer `delete_all_option_vec_option_i_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_option_vec_option_i_32:delete_all_option_vec_option_i_32_then`] to run a callback after the reducer completes. + fn delete_all_option_vec_option_i_32(&self, v: Option>>) -> __sdk::Result<()> { + self.delete_all_option_vec_option_i_32_then(v, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_option_vec_option_i_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_option_vec_option_i_32_then( + &self, + v: Option>>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_option_vec_option_i_32 for super::RemoteReducers { + fn delete_all_option_vec_option_i_32_then( + &self, + v: Option>>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllOptionVecOptionI32Args { v }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_bool_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_bool_reducer.rs new file mode 100644 index 00000000000..1e39a8d030a --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_bool_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkBoolArgs { + pub b: bool, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkBoolArgs) -> Self { + Self::DeleteAllPkBool { + b: args.b, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkBoolArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_bool`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_bool { + /// Request that the remote module invoke the reducer `delete_all_pk_bool` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_bool:delete_all_pk_bool_then`] to run a callback after the reducer completes. + fn delete_all_pk_bool(&self, b: bool, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_bool_then(b, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_bool` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_bool_then( + &self, + b: bool, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_bool for super::RemoteReducers { + fn delete_all_pk_bool_then( + &self, + b: bool, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkBoolArgs { b, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_connection_id_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_connection_id_reducer.rs new file mode 100644 index 00000000000..2110889c9dd --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_connection_id_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkConnectionIdArgs { + pub a: __sdk::ConnectionId, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkConnectionIdArgs) -> Self { + Self::DeleteAllPkConnectionId { + a: args.a, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkConnectionIdArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_connection_id`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_connection_id { + /// Request that the remote module invoke the reducer `delete_all_pk_connection_id` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_connection_id:delete_all_pk_connection_id_then`] to run a callback after the reducer completes. + fn delete_all_pk_connection_id(&self, a: __sdk::ConnectionId, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_connection_id_then(a, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_connection_id` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_connection_id_then( + &self, + a: __sdk::ConnectionId, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_connection_id for super::RemoteReducers { + fn delete_all_pk_connection_id_then( + &self, + a: __sdk::ConnectionId, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkConnectionIdArgs { a, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_128_reducer.rs new file mode 100644 index 00000000000..7b36200edc2 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_128_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkI128Args { + pub n: i128, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkI128Args) -> Self { + Self::DeleteAllPkI128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkI128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_i_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_i_128 { + /// Request that the remote module invoke the reducer `delete_all_pk_i_128` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_i_128:delete_all_pk_i_128_then`] to run a callback after the reducer completes. + fn delete_all_pk_i_128(&self, n: i128, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_i_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_i_128` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_i_128_then( + &self, + n: i128, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_i_128 for super::RemoteReducers { + fn delete_all_pk_i_128_then( + &self, + n: i128, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkI128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_16_reducer.rs new file mode 100644 index 00000000000..7aab2d9c80d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_16_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkI16Args { + pub n: i16, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkI16Args) -> Self { + Self::DeleteAllPkI16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkI16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_i_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_i_16 { + /// Request that the remote module invoke the reducer `delete_all_pk_i_16` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_i_16:delete_all_pk_i_16_then`] to run a callback after the reducer completes. + fn delete_all_pk_i_16(&self, n: i16, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_i_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_i_16` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_i_16_then( + &self, + n: i16, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_i_16 for super::RemoteReducers { + fn delete_all_pk_i_16_then( + &self, + n: i16, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkI16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_256_reducer.rs new file mode 100644 index 00000000000..08650cb7a4d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_256_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkI256Args { + pub n: __sats::i256, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkI256Args) -> Self { + Self::DeleteAllPkI256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkI256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_i_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_i_256 { + /// Request that the remote module invoke the reducer `delete_all_pk_i_256` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_i_256:delete_all_pk_i_256_then`] to run a callback after the reducer completes. + fn delete_all_pk_i_256(&self, n: __sats::i256, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_i_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_i_256` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_i_256_then( + &self, + n: __sats::i256, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_i_256 for super::RemoteReducers { + fn delete_all_pk_i_256_then( + &self, + n: __sats::i256, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkI256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_32_reducer.rs new file mode 100644 index 00000000000..38d8a5070d4 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_32_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkI32Args { + pub n: i32, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkI32Args) -> Self { + Self::DeleteAllPkI32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_i_32 { + /// Request that the remote module invoke the reducer `delete_all_pk_i_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_i_32:delete_all_pk_i_32_then`] to run a callback after the reducer completes. + fn delete_all_pk_i_32(&self, n: i32, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_i_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_i_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_i_32_then( + &self, + n: i32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_i_32 for super::RemoteReducers { + fn delete_all_pk_i_32_then( + &self, + n: i32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkI32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_64_reducer.rs new file mode 100644 index 00000000000..a38e63d5852 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_64_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkI64Args { + pub n: i64, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkI64Args) -> Self { + Self::DeleteAllPkI64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkI64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_i_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_i_64 { + /// Request that the remote module invoke the reducer `delete_all_pk_i_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_i_64:delete_all_pk_i_64_then`] to run a callback after the reducer completes. + fn delete_all_pk_i_64(&self, n: i64, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_i_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_i_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_i_64_then( + &self, + n: i64, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_i_64 for super::RemoteReducers { + fn delete_all_pk_i_64_then( + &self, + n: i64, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkI64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_8_reducer.rs new file mode 100644 index 00000000000..90be2a19624 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_i_8_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkI8Args { + pub n: i8, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkI8Args) -> Self { + Self::DeleteAllPkI8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkI8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_i_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_i_8 { + /// Request that the remote module invoke the reducer `delete_all_pk_i_8` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_i_8:delete_all_pk_i_8_then`] to run a callback after the reducer completes. + fn delete_all_pk_i_8(&self, n: i8, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_i_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_i_8` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_i_8_then( + &self, + n: i8, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_i_8 for super::RemoteReducers { + fn delete_all_pk_i_8_then( + &self, + n: i8, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkI8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_identity_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_identity_reducer.rs new file mode 100644 index 00000000000..9187ac04ba2 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_identity_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkIdentityArgs { + pub i: __sdk::Identity, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkIdentityArgs) -> Self { + Self::DeleteAllPkIdentity { + i: args.i, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkIdentityArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_identity`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_identity { + /// Request that the remote module invoke the reducer `delete_all_pk_identity` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_identity:delete_all_pk_identity_then`] to run a callback after the reducer completes. + fn delete_all_pk_identity(&self, i: __sdk::Identity, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_identity_then(i, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_identity` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_identity_then( + &self, + i: __sdk::Identity, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_identity for super::RemoteReducers { + fn delete_all_pk_identity_then( + &self, + i: __sdk::Identity, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkIdentityArgs { i, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_string_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_string_reducer.rs new file mode 100644 index 00000000000..d9b36829ba0 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_string_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkStringArgs { + pub s: String, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkStringArgs) -> Self { + Self::DeleteAllPkString { + s: args.s, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkStringArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_string`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_string { + /// Request that the remote module invoke the reducer `delete_all_pk_string` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_string:delete_all_pk_string_then`] to run a callback after the reducer completes. + fn delete_all_pk_string(&self, s: String, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_string_then(s, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_string` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_string_then( + &self, + s: String, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_string for super::RemoteReducers { + fn delete_all_pk_string_then( + &self, + s: String, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkStringArgs { s, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_128_reducer.rs new file mode 100644 index 00000000000..0db638693f0 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_128_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkU128Args { + pub n: u128, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkU128Args) -> Self { + Self::DeleteAllPkU128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkU128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_u_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_u_128 { + /// Request that the remote module invoke the reducer `delete_all_pk_u_128` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_u_128:delete_all_pk_u_128_then`] to run a callback after the reducer completes. + fn delete_all_pk_u_128(&self, n: u128, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_u_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_u_128` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_u_128_then( + &self, + n: u128, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_u_128 for super::RemoteReducers { + fn delete_all_pk_u_128_then( + &self, + n: u128, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkU128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_16_reducer.rs new file mode 100644 index 00000000000..f30552dab55 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_16_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkU16Args { + pub n: u16, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkU16Args) -> Self { + Self::DeleteAllPkU16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkU16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_u_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_u_16 { + /// Request that the remote module invoke the reducer `delete_all_pk_u_16` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_u_16:delete_all_pk_u_16_then`] to run a callback after the reducer completes. + fn delete_all_pk_u_16(&self, n: u16, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_u_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_u_16` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_u_16_then( + &self, + n: u16, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_u_16 for super::RemoteReducers { + fn delete_all_pk_u_16_then( + &self, + n: u16, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkU16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_256_reducer.rs new file mode 100644 index 00000000000..55306fb9a6c --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_256_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkU256Args { + pub n: __sats::u256, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkU256Args) -> Self { + Self::DeleteAllPkU256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkU256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_u_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_u_256 { + /// Request that the remote module invoke the reducer `delete_all_pk_u_256` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_u_256:delete_all_pk_u_256_then`] to run a callback after the reducer completes. + fn delete_all_pk_u_256(&self, n: __sats::u256, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_u_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_u_256` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_u_256_then( + &self, + n: __sats::u256, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_u_256 for super::RemoteReducers { + fn delete_all_pk_u_256_then( + &self, + n: __sats::u256, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkU256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_32_reducer.rs new file mode 100644 index 00000000000..ed971a5f779 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_32_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkU32Args { + pub n: u32, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkU32Args) -> Self { + Self::DeleteAllPkU32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkU32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_u_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_u_32 { + /// Request that the remote module invoke the reducer `delete_all_pk_u_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_u_32:delete_all_pk_u_32_then`] to run a callback after the reducer completes. + fn delete_all_pk_u_32(&self, n: u32, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_u_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_u_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_u_32_then( + &self, + n: u32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_u_32 for super::RemoteReducers { + fn delete_all_pk_u_32_then( + &self, + n: u32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkU32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_32_two_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_32_two_reducer.rs new file mode 100644 index 00000000000..4bb1e59c95a --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_32_two_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkU32TwoArgs { + pub n: u32, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkU32TwoArgs) -> Self { + Self::DeleteAllPkU32Two { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkU32TwoArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_u_32_two`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_u_32_two { + /// Request that the remote module invoke the reducer `delete_all_pk_u_32_two` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_u_32_two:delete_all_pk_u_32_two_then`] to run a callback after the reducer completes. + fn delete_all_pk_u_32_two(&self, n: u32, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_u_32_two_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_u_32_two` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_u_32_two_then( + &self, + n: u32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_u_32_two for super::RemoteReducers { + fn delete_all_pk_u_32_two_then( + &self, + n: u32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkU32TwoArgs { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_64_reducer.rs new file mode 100644 index 00000000000..86ce732aa21 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_64_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkU64Args { + pub n: u64, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkU64Args) -> Self { + Self::DeleteAllPkU64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkU64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_u_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_u_64 { + /// Request that the remote module invoke the reducer `delete_all_pk_u_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_u_64:delete_all_pk_u_64_then`] to run a callback after the reducer completes. + fn delete_all_pk_u_64(&self, n: u64, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_u_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_u_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_u_64_then( + &self, + n: u64, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_u_64 for super::RemoteReducers { + fn delete_all_pk_u_64_then( + &self, + n: u64, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkU64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_8_reducer.rs new file mode 100644 index 00000000000..01d73ffc19a --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_u_8_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkU8Args { + pub n: u8, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkU8Args) -> Self { + Self::DeleteAllPkU8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkU8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_u_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_u_8 { + /// Request that the remote module invoke the reducer `delete_all_pk_u_8` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_u_8:delete_all_pk_u_8_then`] to run a callback after the reducer completes. + fn delete_all_pk_u_8(&self, n: u8, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_u_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_u_8` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_u_8_then( + &self, + n: u8, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_u_8 for super::RemoteReducers { + fn delete_all_pk_u_8_then( + &self, + n: u8, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkU8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_uuid_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_uuid_reducer.rs new file mode 100644 index 00000000000..30f3e4ce65d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_pk_uuid_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllPkUuidArgs { + pub u: __sdk::Uuid, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllPkUuidArgs) -> Self { + Self::DeleteAllPkUuid { + u: args.u, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllPkUuidArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_pk_uuid`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_pk_uuid { + /// Request that the remote module invoke the reducer `delete_all_pk_uuid` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_pk_uuid:delete_all_pk_uuid_then`] to run a callback after the reducer completes. + fn delete_all_pk_uuid(&self, u: __sdk::Uuid, data: i32) -> __sdk::Result<()> { + self.delete_all_pk_uuid_then(u, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_pk_uuid` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_pk_uuid_then( + &self, + u: __sdk::Uuid, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_pk_uuid for super::RemoteReducers { + fn delete_all_pk_uuid_then( + &self, + u: __sdk::Uuid, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllPkUuidArgs { u, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_bool_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_bool_reducer.rs new file mode 100644 index 00000000000..69060b0c614 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_bool_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueBoolArgs { + pub b: bool, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueBoolArgs) -> Self { + Self::DeleteAllUniqueBool { + b: args.b, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueBoolArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_bool`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_bool { + /// Request that the remote module invoke the reducer `delete_all_unique_bool` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_bool:delete_all_unique_bool_then`] to run a callback after the reducer completes. + fn delete_all_unique_bool(&self, b: bool, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_bool_then(b, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_bool` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_bool_then( + &self, + b: bool, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_bool for super::RemoteReducers { + fn delete_all_unique_bool_then( + &self, + b: bool, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueBoolArgs { b, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_connection_id_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_connection_id_reducer.rs new file mode 100644 index 00000000000..41673595370 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_connection_id_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueConnectionIdArgs { + pub a: __sdk::ConnectionId, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueConnectionIdArgs) -> Self { + Self::DeleteAllUniqueConnectionId { + a: args.a, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueConnectionIdArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_connection_id`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_connection_id { + /// Request that the remote module invoke the reducer `delete_all_unique_connection_id` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_connection_id:delete_all_unique_connection_id_then`] to run a callback after the reducer completes. + fn delete_all_unique_connection_id(&self, a: __sdk::ConnectionId, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_connection_id_then(a, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_connection_id` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_connection_id_then( + &self, + a: __sdk::ConnectionId, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_connection_id for super::RemoteReducers { + fn delete_all_unique_connection_id_then( + &self, + a: __sdk::ConnectionId, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueConnectionIdArgs { a, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_128_reducer.rs new file mode 100644 index 00000000000..fa3762f8378 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_128_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueI128Args { + pub n: i128, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueI128Args) -> Self { + Self::DeleteAllUniqueI128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueI128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_i_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_i_128 { + /// Request that the remote module invoke the reducer `delete_all_unique_i_128` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_i_128:delete_all_unique_i_128_then`] to run a callback after the reducer completes. + fn delete_all_unique_i_128(&self, n: i128, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_i_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_i_128` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_i_128_then( + &self, + n: i128, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_i_128 for super::RemoteReducers { + fn delete_all_unique_i_128_then( + &self, + n: i128, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueI128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_16_reducer.rs new file mode 100644 index 00000000000..b0c7d096d32 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_16_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueI16Args { + pub n: i16, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueI16Args) -> Self { + Self::DeleteAllUniqueI16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueI16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_i_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_i_16 { + /// Request that the remote module invoke the reducer `delete_all_unique_i_16` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_i_16:delete_all_unique_i_16_then`] to run a callback after the reducer completes. + fn delete_all_unique_i_16(&self, n: i16, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_i_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_i_16` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_i_16_then( + &self, + n: i16, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_i_16 for super::RemoteReducers { + fn delete_all_unique_i_16_then( + &self, + n: i16, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueI16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_256_reducer.rs new file mode 100644 index 00000000000..91e23f4556e --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_256_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueI256Args { + pub n: __sats::i256, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueI256Args) -> Self { + Self::DeleteAllUniqueI256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueI256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_i_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_i_256 { + /// Request that the remote module invoke the reducer `delete_all_unique_i_256` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_i_256:delete_all_unique_i_256_then`] to run a callback after the reducer completes. + fn delete_all_unique_i_256(&self, n: __sats::i256, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_i_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_i_256` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_i_256_then( + &self, + n: __sats::i256, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_i_256 for super::RemoteReducers { + fn delete_all_unique_i_256_then( + &self, + n: __sats::i256, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueI256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_32_reducer.rs new file mode 100644 index 00000000000..9225c938634 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_32_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueI32Args { + pub n: i32, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueI32Args) -> Self { + Self::DeleteAllUniqueI32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_i_32 { + /// Request that the remote module invoke the reducer `delete_all_unique_i_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_i_32:delete_all_unique_i_32_then`] to run a callback after the reducer completes. + fn delete_all_unique_i_32(&self, n: i32, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_i_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_i_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_i_32_then( + &self, + n: i32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_i_32 for super::RemoteReducers { + fn delete_all_unique_i_32_then( + &self, + n: i32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueI32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_64_reducer.rs new file mode 100644 index 00000000000..59d54987864 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_64_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueI64Args { + pub n: i64, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueI64Args) -> Self { + Self::DeleteAllUniqueI64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueI64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_i_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_i_64 { + /// Request that the remote module invoke the reducer `delete_all_unique_i_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_i_64:delete_all_unique_i_64_then`] to run a callback after the reducer completes. + fn delete_all_unique_i_64(&self, n: i64, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_i_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_i_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_i_64_then( + &self, + n: i64, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_i_64 for super::RemoteReducers { + fn delete_all_unique_i_64_then( + &self, + n: i64, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueI64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_8_reducer.rs new file mode 100644 index 00000000000..061dbb0947d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_i_8_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueI8Args { + pub n: i8, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueI8Args) -> Self { + Self::DeleteAllUniqueI8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueI8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_i_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_i_8 { + /// Request that the remote module invoke the reducer `delete_all_unique_i_8` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_i_8:delete_all_unique_i_8_then`] to run a callback after the reducer completes. + fn delete_all_unique_i_8(&self, n: i8, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_i_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_i_8` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_i_8_then( + &self, + n: i8, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_i_8 for super::RemoteReducers { + fn delete_all_unique_i_8_then( + &self, + n: i8, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueI8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_identity_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_identity_reducer.rs new file mode 100644 index 00000000000..ccc40f25d0b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_identity_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueIdentityArgs { + pub i: __sdk::Identity, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueIdentityArgs) -> Self { + Self::DeleteAllUniqueIdentity { + i: args.i, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueIdentityArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_identity`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_identity { + /// Request that the remote module invoke the reducer `delete_all_unique_identity` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_identity:delete_all_unique_identity_then`] to run a callback after the reducer completes. + fn delete_all_unique_identity(&self, i: __sdk::Identity, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_identity_then(i, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_identity` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_identity_then( + &self, + i: __sdk::Identity, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_identity for super::RemoteReducers { + fn delete_all_unique_identity_then( + &self, + i: __sdk::Identity, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueIdentityArgs { i, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_string_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_string_reducer.rs new file mode 100644 index 00000000000..b5f330a86ed --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_string_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueStringArgs { + pub s: String, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueStringArgs) -> Self { + Self::DeleteAllUniqueString { + s: args.s, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueStringArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_string`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_string { + /// Request that the remote module invoke the reducer `delete_all_unique_string` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_string:delete_all_unique_string_then`] to run a callback after the reducer completes. + fn delete_all_unique_string(&self, s: String, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_string_then(s, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_string` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_string_then( + &self, + s: String, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_string for super::RemoteReducers { + fn delete_all_unique_string_then( + &self, + s: String, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueStringArgs { s, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_128_reducer.rs new file mode 100644 index 00000000000..0ca6848c31e --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_128_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueU128Args { + pub n: u128, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueU128Args) -> Self { + Self::DeleteAllUniqueU128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueU128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_u_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_u_128 { + /// Request that the remote module invoke the reducer `delete_all_unique_u_128` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_u_128:delete_all_unique_u_128_then`] to run a callback after the reducer completes. + fn delete_all_unique_u_128(&self, n: u128, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_u_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_u_128` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_u_128_then( + &self, + n: u128, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_u_128 for super::RemoteReducers { + fn delete_all_unique_u_128_then( + &self, + n: u128, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueU128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_16_reducer.rs new file mode 100644 index 00000000000..6d9ddd06481 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_16_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueU16Args { + pub n: u16, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueU16Args) -> Self { + Self::DeleteAllUniqueU16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueU16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_u_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_u_16 { + /// Request that the remote module invoke the reducer `delete_all_unique_u_16` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_u_16:delete_all_unique_u_16_then`] to run a callback after the reducer completes. + fn delete_all_unique_u_16(&self, n: u16, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_u_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_u_16` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_u_16_then( + &self, + n: u16, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_u_16 for super::RemoteReducers { + fn delete_all_unique_u_16_then( + &self, + n: u16, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueU16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_256_reducer.rs new file mode 100644 index 00000000000..d03f2b851c5 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_256_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueU256Args { + pub n: __sats::u256, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueU256Args) -> Self { + Self::DeleteAllUniqueU256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueU256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_u_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_u_256 { + /// Request that the remote module invoke the reducer `delete_all_unique_u_256` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_u_256:delete_all_unique_u_256_then`] to run a callback after the reducer completes. + fn delete_all_unique_u_256(&self, n: __sats::u256, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_u_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_u_256` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_u_256_then( + &self, + n: __sats::u256, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_u_256 for super::RemoteReducers { + fn delete_all_unique_u_256_then( + &self, + n: __sats::u256, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueU256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_32_reducer.rs new file mode 100644 index 00000000000..5ecaf3a7177 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_32_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueU32Args { + pub n: u32, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueU32Args) -> Self { + Self::DeleteAllUniqueU32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueU32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_u_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_u_32 { + /// Request that the remote module invoke the reducer `delete_all_unique_u_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_u_32:delete_all_unique_u_32_then`] to run a callback after the reducer completes. + fn delete_all_unique_u_32(&self, n: u32, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_u_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_u_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_u_32_then( + &self, + n: u32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_u_32 for super::RemoteReducers { + fn delete_all_unique_u_32_then( + &self, + n: u32, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueU32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_64_reducer.rs new file mode 100644 index 00000000000..e2c19a5a812 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_64_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueU64Args { + pub n: u64, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueU64Args) -> Self { + Self::DeleteAllUniqueU64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueU64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_u_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_u_64 { + /// Request that the remote module invoke the reducer `delete_all_unique_u_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_u_64:delete_all_unique_u_64_then`] to run a callback after the reducer completes. + fn delete_all_unique_u_64(&self, n: u64, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_u_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_u_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_u_64_then( + &self, + n: u64, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_u_64 for super::RemoteReducers { + fn delete_all_unique_u_64_then( + &self, + n: u64, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueU64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_8_reducer.rs new file mode 100644 index 00000000000..9a085e4180d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_u_8_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueU8Args { + pub n: u8, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueU8Args) -> Self { + Self::DeleteAllUniqueU8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueU8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_u_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_u_8 { + /// Request that the remote module invoke the reducer `delete_all_unique_u_8` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_u_8:delete_all_unique_u_8_then`] to run a callback after the reducer completes. + fn delete_all_unique_u_8(&self, n: u8, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_u_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_u_8` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_u_8_then( + &self, + n: u8, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_u_8 for super::RemoteReducers { + fn delete_all_unique_u_8_then( + &self, + n: u8, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueU8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_uuid_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_uuid_reducer.rs new file mode 100644 index 00000000000..7a7bc10b522 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_uuid_reducer.rs @@ -0,0 +1,72 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllUniqueUuidArgs { + pub u: __sdk::Uuid, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueUuidArgs) -> Self { + Self::DeleteAllUniqueUuid { + u: args.u, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueUuidArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_uuid`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_uuid { + /// Request that the remote module invoke the reducer `delete_all_unique_uuid` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_unique_uuid:delete_all_unique_uuid_then`] to run a callback after the reducer completes. + fn delete_all_unique_uuid(&self, u: __sdk::Uuid, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_uuid_then(u, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_uuid` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_unique_uuid_then( + &self, + u: __sdk::Uuid, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_uuid for super::RemoteReducers { + fn delete_all_unique_uuid_then( + &self, + u: __sdk::Uuid, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueUuidArgs { u, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_bool_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_bool_reducer.rs new file mode 100644 index 00000000000..952ea1db62e --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_bool_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecBoolArgs { + pub b: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecBoolArgs) -> Self { + Self::DeleteAllVecBool { b: args.b } + } +} + +impl __sdk::InModule for DeleteAllVecBoolArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_bool`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_bool { + /// Request that the remote module invoke the reducer `delete_all_vec_bool` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_bool:delete_all_vec_bool_then`] to run a callback after the reducer completes. + fn delete_all_vec_bool(&self, b: Vec) -> __sdk::Result<()> { + self.delete_all_vec_bool_then(b, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_bool` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_bool_then( + &self, + b: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_bool for super::RemoteReducers { + fn delete_all_vec_bool_then( + &self, + b: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecBoolArgs { b }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_byte_struct_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_byte_struct_reducer.rs new file mode 100644 index 00000000000..ff113bd7655 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_byte_struct_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::byte_struct_type::ByteStruct; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecByteStructArgs { + pub s: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecByteStructArgs) -> Self { + Self::DeleteAllVecByteStruct { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllVecByteStructArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_byte_struct`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_byte_struct { + /// Request that the remote module invoke the reducer `delete_all_vec_byte_struct` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_byte_struct:delete_all_vec_byte_struct_then`] to run a callback after the reducer completes. + fn delete_all_vec_byte_struct(&self, s: Vec) -> __sdk::Result<()> { + self.delete_all_vec_byte_struct_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_byte_struct` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_byte_struct_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_byte_struct for super::RemoteReducers { + fn delete_all_vec_byte_struct_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecByteStructArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_enum_with_payload_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_enum_with_payload_reducer.rs new file mode 100644 index 00000000000..01cfa9e4a51 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_enum_with_payload_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::enum_with_payload_type::EnumWithPayload; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecEnumWithPayloadArgs { + pub e: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecEnumWithPayloadArgs) -> Self { + Self::DeleteAllVecEnumWithPayload { e: args.e } + } +} + +impl __sdk::InModule for DeleteAllVecEnumWithPayloadArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_enum_with_payload`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_enum_with_payload { + /// Request that the remote module invoke the reducer `delete_all_vec_enum_with_payload` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_enum_with_payload:delete_all_vec_enum_with_payload_then`] to run a callback after the reducer completes. + fn delete_all_vec_enum_with_payload(&self, e: Vec) -> __sdk::Result<()> { + self.delete_all_vec_enum_with_payload_then(e, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_enum_with_payload` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_enum_with_payload_then( + &self, + e: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_enum_with_payload for super::RemoteReducers { + fn delete_all_vec_enum_with_payload_then( + &self, + e: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecEnumWithPayloadArgs { e }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_every_primitive_struct_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_every_primitive_struct_reducer.rs new file mode 100644 index 00000000000..66b3db06f93 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_every_primitive_struct_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::every_primitive_struct_type::EveryPrimitiveStruct; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecEveryPrimitiveStructArgs { + pub s: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecEveryPrimitiveStructArgs) -> Self { + Self::DeleteAllVecEveryPrimitiveStruct { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllVecEveryPrimitiveStructArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_every_primitive_struct`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_every_primitive_struct { + /// Request that the remote module invoke the reducer `delete_all_vec_every_primitive_struct` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_every_primitive_struct:delete_all_vec_every_primitive_struct_then`] to run a callback after the reducer completes. + fn delete_all_vec_every_primitive_struct(&self, s: Vec) -> __sdk::Result<()> { + self.delete_all_vec_every_primitive_struct_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_every_primitive_struct` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_every_primitive_struct_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_every_primitive_struct for super::RemoteReducers { + fn delete_all_vec_every_primitive_struct_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecEveryPrimitiveStructArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_every_vec_struct_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_every_vec_struct_reducer.rs new file mode 100644 index 00000000000..40bd8e6d235 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_every_vec_struct_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::every_vec_struct_type::EveryVecStruct; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecEveryVecStructArgs { + pub s: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecEveryVecStructArgs) -> Self { + Self::DeleteAllVecEveryVecStruct { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllVecEveryVecStructArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_every_vec_struct`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_every_vec_struct { + /// Request that the remote module invoke the reducer `delete_all_vec_every_vec_struct` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_every_vec_struct:delete_all_vec_every_vec_struct_then`] to run a callback after the reducer completes. + fn delete_all_vec_every_vec_struct(&self, s: Vec) -> __sdk::Result<()> { + self.delete_all_vec_every_vec_struct_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_every_vec_struct` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_every_vec_struct_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_every_vec_struct for super::RemoteReducers { + fn delete_all_vec_every_vec_struct_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecEveryVecStructArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_f_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_f_32_reducer.rs new file mode 100644 index 00000000000..16505047ffc --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_f_32_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecF32Args { + pub f: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecF32Args) -> Self { + Self::DeleteAllVecF32 { f: args.f } + } +} + +impl __sdk::InModule for DeleteAllVecF32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_f_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_f_32 { + /// Request that the remote module invoke the reducer `delete_all_vec_f_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_f_32:delete_all_vec_f_32_then`] to run a callback after the reducer completes. + fn delete_all_vec_f_32(&self, f: Vec) -> __sdk::Result<()> { + self.delete_all_vec_f_32_then(f, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_f_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_f_32_then( + &self, + f: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_f_32 for super::RemoteReducers { + fn delete_all_vec_f_32_then( + &self, + f: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecF32Args { f }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_f_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_f_64_reducer.rs new file mode 100644 index 00000000000..8b58b92bebd --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_f_64_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecF64Args { + pub f: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecF64Args) -> Self { + Self::DeleteAllVecF64 { f: args.f } + } +} + +impl __sdk::InModule for DeleteAllVecF64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_f_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_f_64 { + /// Request that the remote module invoke the reducer `delete_all_vec_f_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_f_64:delete_all_vec_f_64_then`] to run a callback after the reducer completes. + fn delete_all_vec_f_64(&self, f: Vec) -> __sdk::Result<()> { + self.delete_all_vec_f_64_then(f, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_f_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_f_64_then( + &self, + f: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_f_64 for super::RemoteReducers { + fn delete_all_vec_f_64_then( + &self, + f: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecF64Args { f }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_128_reducer.rs new file mode 100644 index 00000000000..a927cd9307b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_128_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecI128Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecI128Args) -> Self { + Self::DeleteAllVecI128 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecI128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_i_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_i_128 { + /// Request that the remote module invoke the reducer `delete_all_vec_i_128` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_i_128:delete_all_vec_i_128_then`] to run a callback after the reducer completes. + fn delete_all_vec_i_128(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_i_128_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_i_128` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_i_128_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_i_128 for super::RemoteReducers { + fn delete_all_vec_i_128_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecI128Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_16_reducer.rs new file mode 100644 index 00000000000..f53d964fe6e --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_16_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecI16Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecI16Args) -> Self { + Self::DeleteAllVecI16 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecI16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_i_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_i_16 { + /// Request that the remote module invoke the reducer `delete_all_vec_i_16` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_i_16:delete_all_vec_i_16_then`] to run a callback after the reducer completes. + fn delete_all_vec_i_16(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_i_16_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_i_16` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_i_16_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_i_16 for super::RemoteReducers { + fn delete_all_vec_i_16_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecI16Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_256_reducer.rs new file mode 100644 index 00000000000..64d0d819b9c --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_256_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecI256Args { + pub n: Vec<__sats::i256>, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecI256Args) -> Self { + Self::DeleteAllVecI256 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecI256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_i_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_i_256 { + /// Request that the remote module invoke the reducer `delete_all_vec_i_256` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_i_256:delete_all_vec_i_256_then`] to run a callback after the reducer completes. + fn delete_all_vec_i_256(&self, n: Vec<__sats::i256>) -> __sdk::Result<()> { + self.delete_all_vec_i_256_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_i_256` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_i_256_then( + &self, + n: Vec<__sats::i256>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_i_256 for super::RemoteReducers { + fn delete_all_vec_i_256_then( + &self, + n: Vec<__sats::i256>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecI256Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_32_reducer.rs new file mode 100644 index 00000000000..708e02a42b5 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_32_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecI32Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecI32Args) -> Self { + Self::DeleteAllVecI32 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_i_32 { + /// Request that the remote module invoke the reducer `delete_all_vec_i_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_i_32:delete_all_vec_i_32_then`] to run a callback after the reducer completes. + fn delete_all_vec_i_32(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_i_32_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_i_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_i_32_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_i_32 for super::RemoteReducers { + fn delete_all_vec_i_32_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecI32Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_64_reducer.rs new file mode 100644 index 00000000000..a5b4e53a14f --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_64_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecI64Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecI64Args) -> Self { + Self::DeleteAllVecI64 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecI64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_i_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_i_64 { + /// Request that the remote module invoke the reducer `delete_all_vec_i_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_i_64:delete_all_vec_i_64_then`] to run a callback after the reducer completes. + fn delete_all_vec_i_64(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_i_64_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_i_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_i_64_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_i_64 for super::RemoteReducers { + fn delete_all_vec_i_64_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecI64Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_8_reducer.rs new file mode 100644 index 00000000000..6cf59f76409 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_i_8_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecI8Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecI8Args) -> Self { + Self::DeleteAllVecI8 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecI8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_i_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_i_8 { + /// Request that the remote module invoke the reducer `delete_all_vec_i_8` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_i_8:delete_all_vec_i_8_then`] to run a callback after the reducer completes. + fn delete_all_vec_i_8(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_i_8_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_i_8` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_i_8_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_i_8 for super::RemoteReducers { + fn delete_all_vec_i_8_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecI8Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_identity_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_identity_reducer.rs new file mode 100644 index 00000000000..9ee7fd3fde0 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_identity_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecIdentityArgs { + pub i: Vec<__sdk::Identity>, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecIdentityArgs) -> Self { + Self::DeleteAllVecIdentity { i: args.i } + } +} + +impl __sdk::InModule for DeleteAllVecIdentityArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_identity`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_identity { + /// Request that the remote module invoke the reducer `delete_all_vec_identity` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_identity:delete_all_vec_identity_then`] to run a callback after the reducer completes. + fn delete_all_vec_identity(&self, i: Vec<__sdk::Identity>) -> __sdk::Result<()> { + self.delete_all_vec_identity_then(i, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_identity` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_identity_then( + &self, + i: Vec<__sdk::Identity>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_identity for super::RemoteReducers { + fn delete_all_vec_identity_then( + &self, + i: Vec<__sdk::Identity>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecIdentityArgs { i }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_simple_enum_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_simple_enum_reducer.rs new file mode 100644 index 00000000000..20ce2ded2c6 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_simple_enum_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::simple_enum_type::SimpleEnum; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecSimpleEnumArgs { + pub e: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecSimpleEnumArgs) -> Self { + Self::DeleteAllVecSimpleEnum { e: args.e } + } +} + +impl __sdk::InModule for DeleteAllVecSimpleEnumArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_simple_enum`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_simple_enum { + /// Request that the remote module invoke the reducer `delete_all_vec_simple_enum` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_simple_enum:delete_all_vec_simple_enum_then`] to run a callback after the reducer completes. + fn delete_all_vec_simple_enum(&self, e: Vec) -> __sdk::Result<()> { + self.delete_all_vec_simple_enum_then(e, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_simple_enum` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_simple_enum_then( + &self, + e: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_simple_enum for super::RemoteReducers { + fn delete_all_vec_simple_enum_then( + &self, + e: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecSimpleEnumArgs { e }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_string_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_string_reducer.rs new file mode 100644 index 00000000000..b852eda80ed --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_string_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecStringArgs { + pub s: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecStringArgs) -> Self { + Self::DeleteAllVecString { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllVecStringArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_string`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_string { + /// Request that the remote module invoke the reducer `delete_all_vec_string` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_string:delete_all_vec_string_then`] to run a callback after the reducer completes. + fn delete_all_vec_string(&self, s: Vec) -> __sdk::Result<()> { + self.delete_all_vec_string_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_string` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_string_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_string for super::RemoteReducers { + fn delete_all_vec_string_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecStringArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_timestamp_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_timestamp_reducer.rs new file mode 100644 index 00000000000..f72a41e818d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_timestamp_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecTimestampArgs { + pub t: Vec<__sdk::Timestamp>, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecTimestampArgs) -> Self { + Self::DeleteAllVecTimestamp { t: args.t } + } +} + +impl __sdk::InModule for DeleteAllVecTimestampArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_timestamp`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_timestamp { + /// Request that the remote module invoke the reducer `delete_all_vec_timestamp` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_timestamp:delete_all_vec_timestamp_then`] to run a callback after the reducer completes. + fn delete_all_vec_timestamp(&self, t: Vec<__sdk::Timestamp>) -> __sdk::Result<()> { + self.delete_all_vec_timestamp_then(t, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_timestamp` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_timestamp_then( + &self, + t: Vec<__sdk::Timestamp>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_timestamp for super::RemoteReducers { + fn delete_all_vec_timestamp_then( + &self, + t: Vec<__sdk::Timestamp>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecTimestampArgs { t }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_128_reducer.rs new file mode 100644 index 00000000000..1be37e68030 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_128_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecU128Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecU128Args) -> Self { + Self::DeleteAllVecU128 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecU128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_u_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_u_128 { + /// Request that the remote module invoke the reducer `delete_all_vec_u_128` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_u_128:delete_all_vec_u_128_then`] to run a callback after the reducer completes. + fn delete_all_vec_u_128(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_u_128_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_u_128` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_u_128_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_u_128 for super::RemoteReducers { + fn delete_all_vec_u_128_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecU128Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_16_reducer.rs new file mode 100644 index 00000000000..b04693606b0 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_16_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecU16Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecU16Args) -> Self { + Self::DeleteAllVecU16 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecU16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_u_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_u_16 { + /// Request that the remote module invoke the reducer `delete_all_vec_u_16` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_u_16:delete_all_vec_u_16_then`] to run a callback after the reducer completes. + fn delete_all_vec_u_16(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_u_16_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_u_16` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_u_16_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_u_16 for super::RemoteReducers { + fn delete_all_vec_u_16_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecU16Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_256_reducer.rs new file mode 100644 index 00000000000..86db6d41aa8 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_256_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecU256Args { + pub n: Vec<__sats::u256>, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecU256Args) -> Self { + Self::DeleteAllVecU256 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecU256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_u_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_u_256 { + /// Request that the remote module invoke the reducer `delete_all_vec_u_256` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_u_256:delete_all_vec_u_256_then`] to run a callback after the reducer completes. + fn delete_all_vec_u_256(&self, n: Vec<__sats::u256>) -> __sdk::Result<()> { + self.delete_all_vec_u_256_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_u_256` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_u_256_then( + &self, + n: Vec<__sats::u256>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_u_256 for super::RemoteReducers { + fn delete_all_vec_u_256_then( + &self, + n: Vec<__sats::u256>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecU256Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_32_reducer.rs new file mode 100644 index 00000000000..a512ae6e9aa --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_32_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecU32Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecU32Args) -> Self { + Self::DeleteAllVecU32 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecU32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_u_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_u_32 { + /// Request that the remote module invoke the reducer `delete_all_vec_u_32` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_u_32:delete_all_vec_u_32_then`] to run a callback after the reducer completes. + fn delete_all_vec_u_32(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_u_32_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_u_32` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_u_32_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_u_32 for super::RemoteReducers { + fn delete_all_vec_u_32_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecU32Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_64_reducer.rs new file mode 100644 index 00000000000..907f83f6430 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_64_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecU64Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecU64Args) -> Self { + Self::DeleteAllVecU64 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecU64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_u_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_u_64 { + /// Request that the remote module invoke the reducer `delete_all_vec_u_64` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_u_64:delete_all_vec_u_64_then`] to run a callback after the reducer completes. + fn delete_all_vec_u_64(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_u_64_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_u_64` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_u_64_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_u_64 for super::RemoteReducers { + fn delete_all_vec_u_64_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecU64Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_8_reducer.rs new file mode 100644 index 00000000000..2e5be8fb96e --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_u_8_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecU8Args { + pub n: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecU8Args) -> Self { + Self::DeleteAllVecU8 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllVecU8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_u_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_u_8 { + /// Request that the remote module invoke the reducer `delete_all_vec_u_8` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_u_8:delete_all_vec_u_8_then`] to run a callback after the reducer completes. + fn delete_all_vec_u_8(&self, n: Vec) -> __sdk::Result<()> { + self.delete_all_vec_u_8_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_u_8` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_u_8_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_u_8 for super::RemoteReducers { + fn delete_all_vec_u_8_then( + &self, + n: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecU8Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_unit_struct_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_unit_struct_reducer.rs new file mode 100644 index 00000000000..379802983b0 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_unit_struct_reducer.rs @@ -0,0 +1,68 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +use super::unit_struct_type::UnitStruct; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecUnitStructArgs { + pub s: Vec, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecUnitStructArgs) -> Self { + Self::DeleteAllVecUnitStruct { s: args.s } + } +} + +impl __sdk::InModule for DeleteAllVecUnitStructArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_unit_struct`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_unit_struct { + /// Request that the remote module invoke the reducer `delete_all_vec_unit_struct` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_unit_struct:delete_all_vec_unit_struct_then`] to run a callback after the reducer completes. + fn delete_all_vec_unit_struct(&self, s: Vec) -> __sdk::Result<()> { + self.delete_all_vec_unit_struct_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_unit_struct` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_unit_struct_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_unit_struct for super::RemoteReducers { + fn delete_all_vec_unit_struct_then( + &self, + s: Vec, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecUnitStructArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_uuid_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_uuid_reducer.rs new file mode 100644 index 00000000000..34906dac520 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_vec_uuid_reducer.rs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#![allow(unused, clippy::all)] +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)] +#[sats(crate = __lib)] +pub(super) struct DeleteAllVecUuidArgs { + pub u: Vec<__sdk::Uuid>, +} + +impl From for super::Reducer { + fn from(args: DeleteAllVecUuidArgs) -> Self { + Self::DeleteAllVecUuid { u: args.u } + } +} + +impl __sdk::InModule for DeleteAllVecUuidArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_vec_uuid`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_vec_uuid { + /// Request that the remote module invoke the reducer `delete_all_vec_uuid` to run as soon as possible. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and this method provides no way to listen for its completion status. + /// /// Use [`delete_all_vec_uuid:delete_all_vec_uuid_then`] to run a callback after the reducer completes. + fn delete_all_vec_uuid(&self, u: Vec<__sdk::Uuid>) -> __sdk::Result<()> { + self.delete_all_vec_uuid_then(u, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_vec_uuid` to run as soon as possible, + /// registering `callback` to run when we are notified that the reducer completed. + /// + /// This method returns immediately, and errors only if we are unable to send the request. + /// The reducer will run asynchronously in the future, + /// and its status can be observed with the `callback`. + fn delete_all_vec_uuid_then( + &self, + u: Vec<__sdk::Uuid>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_vec_uuid for super::RemoteReducers { + fn delete_all_vec_uuid_then( + &self, + u: Vec<__sdk::Uuid>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllVecUuidArgs { u }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/indexed_table_2_table.rs b/sdks/rust/tests/test-client/src/module_bindings/indexed_table_2_table.rs deleted file mode 100644 index 63eaf2e6ff3..00000000000 --- a/sdks/rust/tests/test-client/src/module_bindings/indexed_table_2_table.rs +++ /dev/null @@ -1,111 +0,0 @@ -// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE -// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. - -#![allow(unused, clippy::all)] -use super::indexed_table_2_type::IndexedTable2; -use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; - -/// Table handle for the table `indexed_table_2`. -/// -/// Obtain a handle from the [`IndexedTable2TableAccess::indexed_table_2`] method on [`super::RemoteTables`], -/// like `ctx.db.indexed_table_2()`. -/// -/// Users are encouraged not to explicitly reference this type, -/// but to directly chain method calls, -/// like `ctx.db.indexed_table_2().on_insert(...)`. -pub struct IndexedTable2TableHandle<'ctx> { - imp: __sdk::TableHandle, - ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, -} - -#[allow(non_camel_case_types)] -/// Extension trait for access to the table `indexed_table_2`. -/// -/// Implemented for [`super::RemoteTables`]. -pub trait IndexedTable2TableAccess { - #[allow(non_snake_case)] - /// Obtain a [`IndexedTable2TableHandle`], which mediates access to the table `indexed_table_2`. - fn indexed_table_2(&self) -> IndexedTable2TableHandle<'_>; -} - -impl IndexedTable2TableAccess for super::RemoteTables { - fn indexed_table_2(&self) -> IndexedTable2TableHandle<'_> { - IndexedTable2TableHandle { - imp: self.imp.get_table::("indexed_table_2"), - ctx: std::marker::PhantomData, - } - } -} - -pub struct IndexedTable2InsertCallbackId(__sdk::CallbackId); -pub struct IndexedTable2DeleteCallbackId(__sdk::CallbackId); - -impl<'ctx> __sdk::Table for IndexedTable2TableHandle<'ctx> { - type Row = IndexedTable2; - type EventContext = super::EventContext; - - fn count(&self) -> u64 { - self.imp.count() - } - fn iter(&self) -> impl Iterator + '_ { - self.imp.iter() - } - - type InsertCallbackId = IndexedTable2InsertCallbackId; - - fn on_insert( - &self, - callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, - ) -> IndexedTable2InsertCallbackId { - IndexedTable2InsertCallbackId(self.imp.on_insert(Box::new(callback))) - } - - fn remove_on_insert(&self, callback: IndexedTable2InsertCallbackId) { - self.imp.remove_on_insert(callback.0) - } - - type DeleteCallbackId = IndexedTable2DeleteCallbackId; - - fn on_delete( - &self, - callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, - ) -> IndexedTable2DeleteCallbackId { - IndexedTable2DeleteCallbackId(self.imp.on_delete(Box::new(callback))) - } - - fn remove_on_delete(&self, callback: IndexedTable2DeleteCallbackId) { - self.imp.remove_on_delete(callback.0) - } -} - -#[doc(hidden)] -pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { - let _table = client_cache.get_or_make_table::("indexed_table_2"); -} - -#[doc(hidden)] -pub(super) fn parse_table_update( - raw_updates: __ws::v2::TableUpdate, -) -> __sdk::Result<__sdk::TableUpdate> { - __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| { - __sdk::InternalError::failed_parse("TableUpdate", "TableUpdate") - .with_cause(e) - .into() - }) -} - -#[allow(non_camel_case_types)] -/// Extension trait for query builder access to the table `IndexedTable2`. -/// -/// Implemented for [`__sdk::QueryTableAccessor`]. -pub trait indexed_table_2QueryTableAccess { - #[allow(non_snake_case)] - /// Get a query builder for the table `IndexedTable2`. - fn indexed_table_2(&self) -> __sdk::__query_builder::Table; -} - -impl indexed_table_2QueryTableAccess for __sdk::QueryTableAccessor { - fn indexed_table_2(&self) -> __sdk::__query_builder::Table { - __sdk::__query_builder::Table::new("indexed_table_2") - } -} diff --git a/sdks/rust/tests/test-client/src/module_bindings/indexed_table_table.rs b/sdks/rust/tests/test-client/src/module_bindings/indexed_table_table.rs deleted file mode 100644 index 73b03043ace..00000000000 --- a/sdks/rust/tests/test-client/src/module_bindings/indexed_table_table.rs +++ /dev/null @@ -1,111 +0,0 @@ -// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE -// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. - -#![allow(unused, clippy::all)] -use super::indexed_table_type::IndexedTable; -use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; - -/// Table handle for the table `indexed_table`. -/// -/// Obtain a handle from the [`IndexedTableTableAccess::indexed_table`] method on [`super::RemoteTables`], -/// like `ctx.db.indexed_table()`. -/// -/// Users are encouraged not to explicitly reference this type, -/// but to directly chain method calls, -/// like `ctx.db.indexed_table().on_insert(...)`. -pub struct IndexedTableTableHandle<'ctx> { - imp: __sdk::TableHandle, - ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, -} - -#[allow(non_camel_case_types)] -/// Extension trait for access to the table `indexed_table`. -/// -/// Implemented for [`super::RemoteTables`]. -pub trait IndexedTableTableAccess { - #[allow(non_snake_case)] - /// Obtain a [`IndexedTableTableHandle`], which mediates access to the table `indexed_table`. - fn indexed_table(&self) -> IndexedTableTableHandle<'_>; -} - -impl IndexedTableTableAccess for super::RemoteTables { - fn indexed_table(&self) -> IndexedTableTableHandle<'_> { - IndexedTableTableHandle { - imp: self.imp.get_table::("indexed_table"), - ctx: std::marker::PhantomData, - } - } -} - -pub struct IndexedTableInsertCallbackId(__sdk::CallbackId); -pub struct IndexedTableDeleteCallbackId(__sdk::CallbackId); - -impl<'ctx> __sdk::Table for IndexedTableTableHandle<'ctx> { - type Row = IndexedTable; - type EventContext = super::EventContext; - - fn count(&self) -> u64 { - self.imp.count() - } - fn iter(&self) -> impl Iterator + '_ { - self.imp.iter() - } - - type InsertCallbackId = IndexedTableInsertCallbackId; - - fn on_insert( - &self, - callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, - ) -> IndexedTableInsertCallbackId { - IndexedTableInsertCallbackId(self.imp.on_insert(Box::new(callback))) - } - - fn remove_on_insert(&self, callback: IndexedTableInsertCallbackId) { - self.imp.remove_on_insert(callback.0) - } - - type DeleteCallbackId = IndexedTableDeleteCallbackId; - - fn on_delete( - &self, - callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, - ) -> IndexedTableDeleteCallbackId { - IndexedTableDeleteCallbackId(self.imp.on_delete(Box::new(callback))) - } - - fn remove_on_delete(&self, callback: IndexedTableDeleteCallbackId) { - self.imp.remove_on_delete(callback.0) - } -} - -#[doc(hidden)] -pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { - let _table = client_cache.get_or_make_table::("indexed_table"); -} - -#[doc(hidden)] -pub(super) fn parse_table_update( - raw_updates: __ws::v2::TableUpdate, -) -> __sdk::Result<__sdk::TableUpdate> { - __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| { - __sdk::InternalError::failed_parse("TableUpdate", "TableUpdate") - .with_cause(e) - .into() - }) -} - -#[allow(non_camel_case_types)] -/// Extension trait for query builder access to the table `IndexedTable`. -/// -/// Implemented for [`__sdk::QueryTableAccessor`]. -pub trait indexed_tableQueryTableAccess { - #[allow(non_snake_case)] - /// Get a query builder for the table `IndexedTable`. - fn indexed_table(&self) -> __sdk::__query_builder::Table; -} - -impl indexed_tableQueryTableAccess for __sdk::QueryTableAccessor { - fn indexed_table(&self) -> __sdk::__query_builder::Table { - __sdk::__query_builder::Table::new("indexed_table") - } -} diff --git a/sdks/rust/tests/test-client/src/module_bindings/mod.rs b/sdks/rust/tests/test-client/src/module_bindings/mod.rs index 50dc1e0cb5a..790bf364709 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/mod.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/mod.rs @@ -1,7 +1,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. -// This was generated using spacetimedb cli version 2.1.0 (commit 77575596072d271b763513ec1833d4a6e0627aef). +// This was generated using spacetimedb cli version 2.3.0 (commit 13a2ffd10f04ab1601f55e19f79cb2909ca44ab5). #![allow(unused, clippy::all)] use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; @@ -9,6 +9,98 @@ use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; pub mod b_tree_u_32_type; pub mod btree_u_32_table; pub mod byte_struct_type; +pub mod delete_all_one_bool_reducer; +pub mod delete_all_one_byte_struct_reducer; +pub mod delete_all_one_enum_with_payload_reducer; +pub mod delete_all_one_every_primitive_struct_reducer; +pub mod delete_all_one_every_vec_struct_reducer; +pub mod delete_all_one_f_32_reducer; +pub mod delete_all_one_f_64_reducer; +pub mod delete_all_one_i_128_reducer; +pub mod delete_all_one_i_16_reducer; +pub mod delete_all_one_i_256_reducer; +pub mod delete_all_one_i_32_reducer; +pub mod delete_all_one_i_64_reducer; +pub mod delete_all_one_i_8_reducer; +pub mod delete_all_one_identity_reducer; +pub mod delete_all_one_simple_enum_reducer; +pub mod delete_all_one_string_reducer; +pub mod delete_all_one_timestamp_reducer; +pub mod delete_all_one_u_128_reducer; +pub mod delete_all_one_u_16_reducer; +pub mod delete_all_one_u_256_reducer; +pub mod delete_all_one_u_32_reducer; +pub mod delete_all_one_u_64_reducer; +pub mod delete_all_one_u_8_reducer; +pub mod delete_all_one_unit_struct_reducer; +pub mod delete_all_one_uuid_reducer; +pub mod delete_all_option_every_primitive_struct_reducer; +pub mod delete_all_option_i_32_reducer; +pub mod delete_all_option_identity_reducer; +pub mod delete_all_option_simple_enum_reducer; +pub mod delete_all_option_string_reducer; +pub mod delete_all_option_uuid_reducer; +pub mod delete_all_option_vec_option_i_32_reducer; +pub mod delete_all_pk_bool_reducer; +pub mod delete_all_pk_connection_id_reducer; +pub mod delete_all_pk_i_128_reducer; +pub mod delete_all_pk_i_16_reducer; +pub mod delete_all_pk_i_256_reducer; +pub mod delete_all_pk_i_32_reducer; +pub mod delete_all_pk_i_64_reducer; +pub mod delete_all_pk_i_8_reducer; +pub mod delete_all_pk_identity_reducer; +pub mod delete_all_pk_string_reducer; +pub mod delete_all_pk_u_128_reducer; +pub mod delete_all_pk_u_16_reducer; +pub mod delete_all_pk_u_256_reducer; +pub mod delete_all_pk_u_32_reducer; +pub mod delete_all_pk_u_32_two_reducer; +pub mod delete_all_pk_u_64_reducer; +pub mod delete_all_pk_u_8_reducer; +pub mod delete_all_pk_uuid_reducer; +pub mod delete_all_unique_bool_reducer; +pub mod delete_all_unique_connection_id_reducer; +pub mod delete_all_unique_i_128_reducer; +pub mod delete_all_unique_i_16_reducer; +pub mod delete_all_unique_i_256_reducer; +pub mod delete_all_unique_i_32_reducer; +pub mod delete_all_unique_i_64_reducer; +pub mod delete_all_unique_i_8_reducer; +pub mod delete_all_unique_identity_reducer; +pub mod delete_all_unique_string_reducer; +pub mod delete_all_unique_u_128_reducer; +pub mod delete_all_unique_u_16_reducer; +pub mod delete_all_unique_u_256_reducer; +pub mod delete_all_unique_u_32_reducer; +pub mod delete_all_unique_u_64_reducer; +pub mod delete_all_unique_u_8_reducer; +pub mod delete_all_unique_uuid_reducer; +pub mod delete_all_vec_bool_reducer; +pub mod delete_all_vec_byte_struct_reducer; +pub mod delete_all_vec_enum_with_payload_reducer; +pub mod delete_all_vec_every_primitive_struct_reducer; +pub mod delete_all_vec_every_vec_struct_reducer; +pub mod delete_all_vec_f_32_reducer; +pub mod delete_all_vec_f_64_reducer; +pub mod delete_all_vec_i_128_reducer; +pub mod delete_all_vec_i_16_reducer; +pub mod delete_all_vec_i_256_reducer; +pub mod delete_all_vec_i_32_reducer; +pub mod delete_all_vec_i_64_reducer; +pub mod delete_all_vec_i_8_reducer; +pub mod delete_all_vec_identity_reducer; +pub mod delete_all_vec_simple_enum_reducer; +pub mod delete_all_vec_string_reducer; +pub mod delete_all_vec_timestamp_reducer; +pub mod delete_all_vec_u_128_reducer; +pub mod delete_all_vec_u_16_reducer; +pub mod delete_all_vec_u_256_reducer; +pub mod delete_all_vec_u_32_reducer; +pub mod delete_all_vec_u_64_reducer; +pub mod delete_all_vec_u_8_reducer; +pub mod delete_all_vec_unit_struct_reducer; +pub mod delete_all_vec_uuid_reducer; pub mod delete_from_btree_u_32_reducer; pub mod delete_large_table_reducer; pub mod delete_pk_bool_reducer; @@ -52,9 +144,7 @@ pub mod every_primitive_struct_type; pub mod every_vec_struct_type; pub mod indexed_simple_enum_table; pub mod indexed_simple_enum_type; -pub mod indexed_table_2_table; pub mod indexed_table_2_type; -pub mod indexed_table_table; pub mod indexed_table_type; pub mod insert_call_timestamp_reducer; pub mod insert_call_uuid_v_4_reducer; @@ -297,7 +387,6 @@ pub mod result_vec_i_32_string_table; pub mod result_vec_i_32_string_type; pub mod scheduled_table_table; pub mod scheduled_table_type; -pub mod send_scheduled_message_reducer; pub mod simple_enum_type; pub mod sorted_uuids_insert_reducer; pub mod table_holds_table_table; @@ -432,6 +521,98 @@ pub mod vec_uuid_type; pub use b_tree_u_32_type::BTreeU32; pub use btree_u_32_table::*; pub use byte_struct_type::ByteStruct; +pub use delete_all_one_bool_reducer::delete_all_one_bool; +pub use delete_all_one_byte_struct_reducer::delete_all_one_byte_struct; +pub use delete_all_one_enum_with_payload_reducer::delete_all_one_enum_with_payload; +pub use delete_all_one_every_primitive_struct_reducer::delete_all_one_every_primitive_struct; +pub use delete_all_one_every_vec_struct_reducer::delete_all_one_every_vec_struct; +pub use delete_all_one_f_32_reducer::delete_all_one_f_32; +pub use delete_all_one_f_64_reducer::delete_all_one_f_64; +pub use delete_all_one_i_128_reducer::delete_all_one_i_128; +pub use delete_all_one_i_16_reducer::delete_all_one_i_16; +pub use delete_all_one_i_256_reducer::delete_all_one_i_256; +pub use delete_all_one_i_32_reducer::delete_all_one_i_32; +pub use delete_all_one_i_64_reducer::delete_all_one_i_64; +pub use delete_all_one_i_8_reducer::delete_all_one_i_8; +pub use delete_all_one_identity_reducer::delete_all_one_identity; +pub use delete_all_one_simple_enum_reducer::delete_all_one_simple_enum; +pub use delete_all_one_string_reducer::delete_all_one_string; +pub use delete_all_one_timestamp_reducer::delete_all_one_timestamp; +pub use delete_all_one_u_128_reducer::delete_all_one_u_128; +pub use delete_all_one_u_16_reducer::delete_all_one_u_16; +pub use delete_all_one_u_256_reducer::delete_all_one_u_256; +pub use delete_all_one_u_32_reducer::delete_all_one_u_32; +pub use delete_all_one_u_64_reducer::delete_all_one_u_64; +pub use delete_all_one_u_8_reducer::delete_all_one_u_8; +pub use delete_all_one_unit_struct_reducer::delete_all_one_unit_struct; +pub use delete_all_one_uuid_reducer::delete_all_one_uuid; +pub use delete_all_option_every_primitive_struct_reducer::delete_all_option_every_primitive_struct; +pub use delete_all_option_i_32_reducer::delete_all_option_i_32; +pub use delete_all_option_identity_reducer::delete_all_option_identity; +pub use delete_all_option_simple_enum_reducer::delete_all_option_simple_enum; +pub use delete_all_option_string_reducer::delete_all_option_string; +pub use delete_all_option_uuid_reducer::delete_all_option_uuid; +pub use delete_all_option_vec_option_i_32_reducer::delete_all_option_vec_option_i_32; +pub use delete_all_pk_bool_reducer::delete_all_pk_bool; +pub use delete_all_pk_connection_id_reducer::delete_all_pk_connection_id; +pub use delete_all_pk_i_128_reducer::delete_all_pk_i_128; +pub use delete_all_pk_i_16_reducer::delete_all_pk_i_16; +pub use delete_all_pk_i_256_reducer::delete_all_pk_i_256; +pub use delete_all_pk_i_32_reducer::delete_all_pk_i_32; +pub use delete_all_pk_i_64_reducer::delete_all_pk_i_64; +pub use delete_all_pk_i_8_reducer::delete_all_pk_i_8; +pub use delete_all_pk_identity_reducer::delete_all_pk_identity; +pub use delete_all_pk_string_reducer::delete_all_pk_string; +pub use delete_all_pk_u_128_reducer::delete_all_pk_u_128; +pub use delete_all_pk_u_16_reducer::delete_all_pk_u_16; +pub use delete_all_pk_u_256_reducer::delete_all_pk_u_256; +pub use delete_all_pk_u_32_reducer::delete_all_pk_u_32; +pub use delete_all_pk_u_32_two_reducer::delete_all_pk_u_32_two; +pub use delete_all_pk_u_64_reducer::delete_all_pk_u_64; +pub use delete_all_pk_u_8_reducer::delete_all_pk_u_8; +pub use delete_all_pk_uuid_reducer::delete_all_pk_uuid; +pub use delete_all_unique_bool_reducer::delete_all_unique_bool; +pub use delete_all_unique_connection_id_reducer::delete_all_unique_connection_id; +pub use delete_all_unique_i_128_reducer::delete_all_unique_i_128; +pub use delete_all_unique_i_16_reducer::delete_all_unique_i_16; +pub use delete_all_unique_i_256_reducer::delete_all_unique_i_256; +pub use delete_all_unique_i_32_reducer::delete_all_unique_i_32; +pub use delete_all_unique_i_64_reducer::delete_all_unique_i_64; +pub use delete_all_unique_i_8_reducer::delete_all_unique_i_8; +pub use delete_all_unique_identity_reducer::delete_all_unique_identity; +pub use delete_all_unique_string_reducer::delete_all_unique_string; +pub use delete_all_unique_u_128_reducer::delete_all_unique_u_128; +pub use delete_all_unique_u_16_reducer::delete_all_unique_u_16; +pub use delete_all_unique_u_256_reducer::delete_all_unique_u_256; +pub use delete_all_unique_u_32_reducer::delete_all_unique_u_32; +pub use delete_all_unique_u_64_reducer::delete_all_unique_u_64; +pub use delete_all_unique_u_8_reducer::delete_all_unique_u_8; +pub use delete_all_unique_uuid_reducer::delete_all_unique_uuid; +pub use delete_all_vec_bool_reducer::delete_all_vec_bool; +pub use delete_all_vec_byte_struct_reducer::delete_all_vec_byte_struct; +pub use delete_all_vec_enum_with_payload_reducer::delete_all_vec_enum_with_payload; +pub use delete_all_vec_every_primitive_struct_reducer::delete_all_vec_every_primitive_struct; +pub use delete_all_vec_every_vec_struct_reducer::delete_all_vec_every_vec_struct; +pub use delete_all_vec_f_32_reducer::delete_all_vec_f_32; +pub use delete_all_vec_f_64_reducer::delete_all_vec_f_64; +pub use delete_all_vec_i_128_reducer::delete_all_vec_i_128; +pub use delete_all_vec_i_16_reducer::delete_all_vec_i_16; +pub use delete_all_vec_i_256_reducer::delete_all_vec_i_256; +pub use delete_all_vec_i_32_reducer::delete_all_vec_i_32; +pub use delete_all_vec_i_64_reducer::delete_all_vec_i_64; +pub use delete_all_vec_i_8_reducer::delete_all_vec_i_8; +pub use delete_all_vec_identity_reducer::delete_all_vec_identity; +pub use delete_all_vec_simple_enum_reducer::delete_all_vec_simple_enum; +pub use delete_all_vec_string_reducer::delete_all_vec_string; +pub use delete_all_vec_timestamp_reducer::delete_all_vec_timestamp; +pub use delete_all_vec_u_128_reducer::delete_all_vec_u_128; +pub use delete_all_vec_u_16_reducer::delete_all_vec_u_16; +pub use delete_all_vec_u_256_reducer::delete_all_vec_u_256; +pub use delete_all_vec_u_32_reducer::delete_all_vec_u_32; +pub use delete_all_vec_u_64_reducer::delete_all_vec_u_64; +pub use delete_all_vec_u_8_reducer::delete_all_vec_u_8; +pub use delete_all_vec_unit_struct_reducer::delete_all_vec_unit_struct; +pub use delete_all_vec_uuid_reducer::delete_all_vec_uuid; pub use delete_from_btree_u_32_reducer::delete_from_btree_u_32; pub use delete_large_table_reducer::delete_large_table; pub use delete_pk_bool_reducer::delete_pk_bool; @@ -475,9 +656,7 @@ pub use every_primitive_struct_type::EveryPrimitiveStruct; pub use every_vec_struct_type::EveryVecStruct; pub use indexed_simple_enum_table::*; pub use indexed_simple_enum_type::IndexedSimpleEnum; -pub use indexed_table_2_table::*; pub use indexed_table_2_type::IndexedTable2; -pub use indexed_table_table::*; pub use indexed_table_type::IndexedTable; pub use insert_call_timestamp_reducer::insert_call_timestamp; pub use insert_call_uuid_v_4_reducer::insert_call_uuid_v_4; @@ -720,7 +899,6 @@ pub use result_vec_i_32_string_table::*; pub use result_vec_i_32_string_type::ResultVecI32String; pub use scheduled_table_table::*; pub use scheduled_table_type::ScheduledTable; -pub use send_scheduled_message_reducer::send_scheduled_message; pub use simple_enum_type::SimpleEnum; pub use sorted_uuids_insert_reducer::sorted_uuids_insert; pub use table_holds_table_table::*; @@ -860,6 +1038,317 @@ pub use vec_uuid_type::VecUuid; /// to indicate which reducer caused the event. pub enum Reducer { + DeleteAllOneBool { + b: bool, + }, + DeleteAllOneByteStruct { + s: ByteStruct, + }, + DeleteAllOneEnumWithPayload { + e: EnumWithPayload, + }, + DeleteAllOneEveryPrimitiveStruct { + s: EveryPrimitiveStruct, + }, + DeleteAllOneEveryVecStruct { + s: EveryVecStruct, + }, + DeleteAllOneF32 { + f: f32, + }, + DeleteAllOneF64 { + f: f64, + }, + DeleteAllOneI128 { + n: i128, + }, + DeleteAllOneI16 { + n: i16, + }, + DeleteAllOneI256 { + n: __sats::i256, + }, + DeleteAllOneI32 { + n: i32, + }, + DeleteAllOneI64 { + n: i64, + }, + DeleteAllOneI8 { + n: i8, + }, + DeleteAllOneIdentity { + i: __sdk::Identity, + }, + DeleteAllOneSimpleEnum { + e: SimpleEnum, + }, + DeleteAllOneString { + s: String, + }, + DeleteAllOneTimestamp { + t: __sdk::Timestamp, + }, + DeleteAllOneU128 { + n: u128, + }, + DeleteAllOneU16 { + n: u16, + }, + DeleteAllOneU256 { + n: __sats::u256, + }, + DeleteAllOneU32 { + n: u32, + }, + DeleteAllOneU64 { + n: u64, + }, + DeleteAllOneU8 { + n: u8, + }, + DeleteAllOneUnitStruct { + s: UnitStruct, + }, + DeleteAllOneUuid { + u: __sdk::Uuid, + }, + DeleteAllOptionEveryPrimitiveStruct { + s: Option, + }, + DeleteAllOptionI32 { + n: Option, + }, + DeleteAllOptionIdentity { + i: Option<__sdk::Identity>, + }, + DeleteAllOptionSimpleEnum { + e: Option, + }, + DeleteAllOptionString { + s: Option, + }, + DeleteAllOptionUuid { + u: Option<__sdk::Uuid>, + }, + DeleteAllOptionVecOptionI32 { + v: Option>>, + }, + DeleteAllPkBool { + b: bool, + data: i32, + }, + DeleteAllPkConnectionId { + a: __sdk::ConnectionId, + data: i32, + }, + DeleteAllPkI128 { + n: i128, + data: i32, + }, + DeleteAllPkI16 { + n: i16, + data: i32, + }, + DeleteAllPkI256 { + n: __sats::i256, + data: i32, + }, + DeleteAllPkI32 { + n: i32, + data: i32, + }, + DeleteAllPkI64 { + n: i64, + data: i32, + }, + DeleteAllPkI8 { + n: i8, + data: i32, + }, + DeleteAllPkIdentity { + i: __sdk::Identity, + data: i32, + }, + DeleteAllPkString { + s: String, + data: i32, + }, + DeleteAllPkU128 { + n: u128, + data: i32, + }, + DeleteAllPkU16 { + n: u16, + data: i32, + }, + DeleteAllPkU256 { + n: __sats::u256, + data: i32, + }, + DeleteAllPkU32 { + n: u32, + data: i32, + }, + DeleteAllPkU32Two { + n: u32, + data: i32, + }, + DeleteAllPkU64 { + n: u64, + data: i32, + }, + DeleteAllPkU8 { + n: u8, + data: i32, + }, + DeleteAllPkUuid { + u: __sdk::Uuid, + data: i32, + }, + DeleteAllUniqueBool { + b: bool, + data: i32, + }, + DeleteAllUniqueConnectionId { + a: __sdk::ConnectionId, + data: i32, + }, + DeleteAllUniqueI128 { + n: i128, + data: i32, + }, + DeleteAllUniqueI16 { + n: i16, + data: i32, + }, + DeleteAllUniqueI256 { + n: __sats::i256, + data: i32, + }, + DeleteAllUniqueI32 { + n: i32, + data: i32, + }, + DeleteAllUniqueI64 { + n: i64, + data: i32, + }, + DeleteAllUniqueI8 { + n: i8, + data: i32, + }, + DeleteAllUniqueIdentity { + i: __sdk::Identity, + data: i32, + }, + DeleteAllUniqueString { + s: String, + data: i32, + }, + DeleteAllUniqueU128 { + n: u128, + data: i32, + }, + DeleteAllUniqueU16 { + n: u16, + data: i32, + }, + DeleteAllUniqueU256 { + n: __sats::u256, + data: i32, + }, + DeleteAllUniqueU32 { + n: u32, + data: i32, + }, + DeleteAllUniqueU64 { + n: u64, + data: i32, + }, + DeleteAllUniqueU8 { + n: u8, + data: i32, + }, + DeleteAllUniqueUuid { + u: __sdk::Uuid, + data: i32, + }, + DeleteAllVecBool { + b: Vec, + }, + DeleteAllVecByteStruct { + s: Vec, + }, + DeleteAllVecEnumWithPayload { + e: Vec, + }, + DeleteAllVecEveryPrimitiveStruct { + s: Vec, + }, + DeleteAllVecEveryVecStruct { + s: Vec, + }, + DeleteAllVecF32 { + f: Vec, + }, + DeleteAllVecF64 { + f: Vec, + }, + DeleteAllVecI128 { + n: Vec, + }, + DeleteAllVecI16 { + n: Vec, + }, + DeleteAllVecI256 { + n: Vec<__sats::i256>, + }, + DeleteAllVecI32 { + n: Vec, + }, + DeleteAllVecI64 { + n: Vec, + }, + DeleteAllVecI8 { + n: Vec, + }, + DeleteAllVecIdentity { + i: Vec<__sdk::Identity>, + }, + DeleteAllVecSimpleEnum { + e: Vec, + }, + DeleteAllVecString { + s: Vec, + }, + DeleteAllVecTimestamp { + t: Vec<__sdk::Timestamp>, + }, + DeleteAllVecU128 { + n: Vec, + }, + DeleteAllVecU16 { + n: Vec, + }, + DeleteAllVecU256 { + n: Vec<__sats::u256>, + }, + DeleteAllVecU32 { + n: Vec, + }, + DeleteAllVecU64 { + n: Vec, + }, + DeleteAllVecU8 { + n: Vec, + }, + DeleteAllVecUnitStruct { + s: Vec, + }, + DeleteAllVecUuid { + u: Vec<__sdk::Uuid>, + }, DeleteFromBtreeU32 { rows: Vec, }, @@ -1405,9 +1894,6 @@ pub enum Reducer { u: Vec<__sdk::Uuid>, }, NoOpSucceeds, - SendScheduledMessage { - arg: ScheduledTable, - }, SortedUuidsInsert, UpdateIndexedSimpleEnum { a: SimpleEnum, @@ -1566,6 +2052,98 @@ impl __sdk::InModule for Reducer { impl __sdk::Reducer for Reducer { fn reducer_name(&self) -> &'static str { match self { + Reducer::DeleteAllOneBool { .. } => "delete_all_one_bool", + Reducer::DeleteAllOneByteStruct { .. } => "delete_all_one_byte_struct", + Reducer::DeleteAllOneEnumWithPayload { .. } => "delete_all_one_enum_with_payload", + Reducer::DeleteAllOneEveryPrimitiveStruct { .. } => "delete_all_one_every_primitive_struct", + Reducer::DeleteAllOneEveryVecStruct { .. } => "delete_all_one_every_vec_struct", + Reducer::DeleteAllOneF32 { .. } => "delete_all_one_f_32", + Reducer::DeleteAllOneF64 { .. } => "delete_all_one_f_64", + Reducer::DeleteAllOneI128 { .. } => "delete_all_one_i_128", + Reducer::DeleteAllOneI16 { .. } => "delete_all_one_i_16", + Reducer::DeleteAllOneI256 { .. } => "delete_all_one_i_256", + Reducer::DeleteAllOneI32 { .. } => "delete_all_one_i_32", + Reducer::DeleteAllOneI64 { .. } => "delete_all_one_i_64", + Reducer::DeleteAllOneI8 { .. } => "delete_all_one_i_8", + Reducer::DeleteAllOneIdentity { .. } => "delete_all_one_identity", + Reducer::DeleteAllOneSimpleEnum { .. } => "delete_all_one_simple_enum", + Reducer::DeleteAllOneString { .. } => "delete_all_one_string", + Reducer::DeleteAllOneTimestamp { .. } => "delete_all_one_timestamp", + Reducer::DeleteAllOneU128 { .. } => "delete_all_one_u_128", + Reducer::DeleteAllOneU16 { .. } => "delete_all_one_u_16", + Reducer::DeleteAllOneU256 { .. } => "delete_all_one_u_256", + Reducer::DeleteAllOneU32 { .. } => "delete_all_one_u_32", + Reducer::DeleteAllOneU64 { .. } => "delete_all_one_u_64", + Reducer::DeleteAllOneU8 { .. } => "delete_all_one_u_8", + Reducer::DeleteAllOneUnitStruct { .. } => "delete_all_one_unit_struct", + Reducer::DeleteAllOneUuid { .. } => "delete_all_one_uuid", + Reducer::DeleteAllOptionEveryPrimitiveStruct { .. } => "delete_all_option_every_primitive_struct", + Reducer::DeleteAllOptionI32 { .. } => "delete_all_option_i_32", + Reducer::DeleteAllOptionIdentity { .. } => "delete_all_option_identity", + Reducer::DeleteAllOptionSimpleEnum { .. } => "delete_all_option_simple_enum", + Reducer::DeleteAllOptionString { .. } => "delete_all_option_string", + Reducer::DeleteAllOptionUuid { .. } => "delete_all_option_uuid", + Reducer::DeleteAllOptionVecOptionI32 { .. } => "delete_all_option_vec_option_i_32", + Reducer::DeleteAllPkBool { .. } => "delete_all_pk_bool", + Reducer::DeleteAllPkConnectionId { .. } => "delete_all_pk_connection_id", + Reducer::DeleteAllPkI128 { .. } => "delete_all_pk_i_128", + Reducer::DeleteAllPkI16 { .. } => "delete_all_pk_i_16", + Reducer::DeleteAllPkI256 { .. } => "delete_all_pk_i_256", + Reducer::DeleteAllPkI32 { .. } => "delete_all_pk_i_32", + Reducer::DeleteAllPkI64 { .. } => "delete_all_pk_i_64", + Reducer::DeleteAllPkI8 { .. } => "delete_all_pk_i_8", + Reducer::DeleteAllPkIdentity { .. } => "delete_all_pk_identity", + Reducer::DeleteAllPkString { .. } => "delete_all_pk_string", + Reducer::DeleteAllPkU128 { .. } => "delete_all_pk_u_128", + Reducer::DeleteAllPkU16 { .. } => "delete_all_pk_u_16", + Reducer::DeleteAllPkU256 { .. } => "delete_all_pk_u_256", + Reducer::DeleteAllPkU32 { .. } => "delete_all_pk_u_32", + Reducer::DeleteAllPkU32Two { .. } => "delete_all_pk_u_32_two", + Reducer::DeleteAllPkU64 { .. } => "delete_all_pk_u_64", + Reducer::DeleteAllPkU8 { .. } => "delete_all_pk_u_8", + Reducer::DeleteAllPkUuid { .. } => "delete_all_pk_uuid", + Reducer::DeleteAllUniqueBool { .. } => "delete_all_unique_bool", + Reducer::DeleteAllUniqueConnectionId { .. } => "delete_all_unique_connection_id", + Reducer::DeleteAllUniqueI128 { .. } => "delete_all_unique_i_128", + Reducer::DeleteAllUniqueI16 { .. } => "delete_all_unique_i_16", + Reducer::DeleteAllUniqueI256 { .. } => "delete_all_unique_i_256", + Reducer::DeleteAllUniqueI32 { .. } => "delete_all_unique_i_32", + Reducer::DeleteAllUniqueI64 { .. } => "delete_all_unique_i_64", + Reducer::DeleteAllUniqueI8 { .. } => "delete_all_unique_i_8", + Reducer::DeleteAllUniqueIdentity { .. } => "delete_all_unique_identity", + Reducer::DeleteAllUniqueString { .. } => "delete_all_unique_string", + Reducer::DeleteAllUniqueU128 { .. } => "delete_all_unique_u_128", + Reducer::DeleteAllUniqueU16 { .. } => "delete_all_unique_u_16", + Reducer::DeleteAllUniqueU256 { .. } => "delete_all_unique_u_256", + Reducer::DeleteAllUniqueU32 { .. } => "delete_all_unique_u_32", + Reducer::DeleteAllUniqueU64 { .. } => "delete_all_unique_u_64", + Reducer::DeleteAllUniqueU8 { .. } => "delete_all_unique_u_8", + Reducer::DeleteAllUniqueUuid { .. } => "delete_all_unique_uuid", + Reducer::DeleteAllVecBool { .. } => "delete_all_vec_bool", + Reducer::DeleteAllVecByteStruct { .. } => "delete_all_vec_byte_struct", + Reducer::DeleteAllVecEnumWithPayload { .. } => "delete_all_vec_enum_with_payload", + Reducer::DeleteAllVecEveryPrimitiveStruct { .. } => "delete_all_vec_every_primitive_struct", + Reducer::DeleteAllVecEveryVecStruct { .. } => "delete_all_vec_every_vec_struct", + Reducer::DeleteAllVecF32 { .. } => "delete_all_vec_f_32", + Reducer::DeleteAllVecF64 { .. } => "delete_all_vec_f_64", + Reducer::DeleteAllVecI128 { .. } => "delete_all_vec_i_128", + Reducer::DeleteAllVecI16 { .. } => "delete_all_vec_i_16", + Reducer::DeleteAllVecI256 { .. } => "delete_all_vec_i_256", + Reducer::DeleteAllVecI32 { .. } => "delete_all_vec_i_32", + Reducer::DeleteAllVecI64 { .. } => "delete_all_vec_i_64", + Reducer::DeleteAllVecI8 { .. } => "delete_all_vec_i_8", + Reducer::DeleteAllVecIdentity { .. } => "delete_all_vec_identity", + Reducer::DeleteAllVecSimpleEnum { .. } => "delete_all_vec_simple_enum", + Reducer::DeleteAllVecString { .. } => "delete_all_vec_string", + Reducer::DeleteAllVecTimestamp { .. } => "delete_all_vec_timestamp", + Reducer::DeleteAllVecU128 { .. } => "delete_all_vec_u_128", + Reducer::DeleteAllVecU16 { .. } => "delete_all_vec_u_16", + Reducer::DeleteAllVecU256 { .. } => "delete_all_vec_u_256", + Reducer::DeleteAllVecU32 { .. } => "delete_all_vec_u_32", + Reducer::DeleteAllVecU64 { .. } => "delete_all_vec_u_64", + Reducer::DeleteAllVecU8 { .. } => "delete_all_vec_u_8", + Reducer::DeleteAllVecUnitStruct { .. } => "delete_all_vec_unit_struct", + Reducer::DeleteAllVecUuid { .. } => "delete_all_vec_uuid", Reducer::DeleteFromBtreeU32 { .. } => "delete_from_btree_u_32", Reducer::DeleteLargeTable { .. } => "delete_large_table", Reducer::DeletePkBool { .. } => "delete_pk_bool", @@ -1725,7 +2303,6 @@ impl __sdk::Reducer for Reducer { Reducer::InsertVecUnitStruct { .. } => "insert_vec_unit_struct", Reducer::InsertVecUuid { .. } => "insert_vec_uuid", Reducer::NoOpSucceeds => "no_op_succeeds", - Reducer::SendScheduledMessage { .. } => "send_scheduled_message", Reducer::SortedUuidsInsert => "sorted_uuids_insert", Reducer::UpdateIndexedSimpleEnum { .. } => "update_indexed_simple_enum", Reducer::UpdatePkBool { .. } => "update_pk_bool", @@ -1770,6 +2347,391 @@ impl __sdk::Reducer for Reducer { #[allow(clippy::clone_on_copy)] fn args_bsatn(&self) -> Result, __sats::bsatn::EncodeError> { match self { + Reducer::DeleteAllOneBool { b } => { + __sats::bsatn::to_vec(&delete_all_one_bool_reducer::DeleteAllOneBoolArgs { b: b.clone() }) + } + Reducer::DeleteAllOneByteStruct { s } => { + __sats::bsatn::to_vec(&delete_all_one_byte_struct_reducer::DeleteAllOneByteStructArgs { s: s.clone() }) + } + Reducer::DeleteAllOneEnumWithPayload { e } => __sats::bsatn::to_vec( + &delete_all_one_enum_with_payload_reducer::DeleteAllOneEnumWithPayloadArgs { e: e.clone() }, + ), + Reducer::DeleteAllOneEveryPrimitiveStruct { s } => __sats::bsatn::to_vec( + &delete_all_one_every_primitive_struct_reducer::DeleteAllOneEveryPrimitiveStructArgs { s: s.clone() }, + ), + Reducer::DeleteAllOneEveryVecStruct { s } => __sats::bsatn::to_vec( + &delete_all_one_every_vec_struct_reducer::DeleteAllOneEveryVecStructArgs { s: s.clone() }, + ), + Reducer::DeleteAllOneF32 { f } => { + __sats::bsatn::to_vec(&delete_all_one_f_32_reducer::DeleteAllOneF32Args { f: f.clone() }) + } + Reducer::DeleteAllOneF64 { f } => { + __sats::bsatn::to_vec(&delete_all_one_f_64_reducer::DeleteAllOneF64Args { f: f.clone() }) + } + Reducer::DeleteAllOneI128 { n } => { + __sats::bsatn::to_vec(&delete_all_one_i_128_reducer::DeleteAllOneI128Args { n: n.clone() }) + } + Reducer::DeleteAllOneI16 { n } => { + __sats::bsatn::to_vec(&delete_all_one_i_16_reducer::DeleteAllOneI16Args { n: n.clone() }) + } + Reducer::DeleteAllOneI256 { n } => { + __sats::bsatn::to_vec(&delete_all_one_i_256_reducer::DeleteAllOneI256Args { n: n.clone() }) + } + Reducer::DeleteAllOneI32 { n } => { + __sats::bsatn::to_vec(&delete_all_one_i_32_reducer::DeleteAllOneI32Args { n: n.clone() }) + } + Reducer::DeleteAllOneI64 { n } => { + __sats::bsatn::to_vec(&delete_all_one_i_64_reducer::DeleteAllOneI64Args { n: n.clone() }) + } + Reducer::DeleteAllOneI8 { n } => { + __sats::bsatn::to_vec(&delete_all_one_i_8_reducer::DeleteAllOneI8Args { n: n.clone() }) + } + Reducer::DeleteAllOneIdentity { i } => { + __sats::bsatn::to_vec(&delete_all_one_identity_reducer::DeleteAllOneIdentityArgs { i: i.clone() }) + } + Reducer::DeleteAllOneSimpleEnum { e } => { + __sats::bsatn::to_vec(&delete_all_one_simple_enum_reducer::DeleteAllOneSimpleEnumArgs { e: e.clone() }) + } + Reducer::DeleteAllOneString { s } => { + __sats::bsatn::to_vec(&delete_all_one_string_reducer::DeleteAllOneStringArgs { s: s.clone() }) + } + Reducer::DeleteAllOneTimestamp { t } => { + __sats::bsatn::to_vec(&delete_all_one_timestamp_reducer::DeleteAllOneTimestampArgs { t: t.clone() }) + } + Reducer::DeleteAllOneU128 { n } => { + __sats::bsatn::to_vec(&delete_all_one_u_128_reducer::DeleteAllOneU128Args { n: n.clone() }) + } + Reducer::DeleteAllOneU16 { n } => { + __sats::bsatn::to_vec(&delete_all_one_u_16_reducer::DeleteAllOneU16Args { n: n.clone() }) + } + Reducer::DeleteAllOneU256 { n } => { + __sats::bsatn::to_vec(&delete_all_one_u_256_reducer::DeleteAllOneU256Args { n: n.clone() }) + } + Reducer::DeleteAllOneU32 { n } => { + __sats::bsatn::to_vec(&delete_all_one_u_32_reducer::DeleteAllOneU32Args { n: n.clone() }) + } + Reducer::DeleteAllOneU64 { n } => { + __sats::bsatn::to_vec(&delete_all_one_u_64_reducer::DeleteAllOneU64Args { n: n.clone() }) + } + Reducer::DeleteAllOneU8 { n } => { + __sats::bsatn::to_vec(&delete_all_one_u_8_reducer::DeleteAllOneU8Args { n: n.clone() }) + } + Reducer::DeleteAllOneUnitStruct { s } => { + __sats::bsatn::to_vec(&delete_all_one_unit_struct_reducer::DeleteAllOneUnitStructArgs { s: s.clone() }) + } + Reducer::DeleteAllOneUuid { u } => { + __sats::bsatn::to_vec(&delete_all_one_uuid_reducer::DeleteAllOneUuidArgs { u: u.clone() }) + } + Reducer::DeleteAllOptionEveryPrimitiveStruct { s } => __sats::bsatn::to_vec( + &delete_all_option_every_primitive_struct_reducer::DeleteAllOptionEveryPrimitiveStructArgs { + s: s.clone(), + }, + ), + Reducer::DeleteAllOptionI32 { n } => { + __sats::bsatn::to_vec(&delete_all_option_i_32_reducer::DeleteAllOptionI32Args { n: n.clone() }) + } + Reducer::DeleteAllOptionIdentity { i } => { + __sats::bsatn::to_vec(&delete_all_option_identity_reducer::DeleteAllOptionIdentityArgs { i: i.clone() }) + } + Reducer::DeleteAllOptionSimpleEnum { e } => { + __sats::bsatn::to_vec(&delete_all_option_simple_enum_reducer::DeleteAllOptionSimpleEnumArgs { + e: e.clone(), + }) + } + Reducer::DeleteAllOptionString { s } => { + __sats::bsatn::to_vec(&delete_all_option_string_reducer::DeleteAllOptionStringArgs { s: s.clone() }) + } + Reducer::DeleteAllOptionUuid { u } => { + __sats::bsatn::to_vec(&delete_all_option_uuid_reducer::DeleteAllOptionUuidArgs { u: u.clone() }) + } + Reducer::DeleteAllOptionVecOptionI32 { v } => __sats::bsatn::to_vec( + &delete_all_option_vec_option_i_32_reducer::DeleteAllOptionVecOptionI32Args { v: v.clone() }, + ), + Reducer::DeleteAllPkBool { b, data } => { + __sats::bsatn::to_vec(&delete_all_pk_bool_reducer::DeleteAllPkBoolArgs { + b: b.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkConnectionId { a, data } => { + __sats::bsatn::to_vec(&delete_all_pk_connection_id_reducer::DeleteAllPkConnectionIdArgs { + a: a.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkI128 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_i_128_reducer::DeleteAllPkI128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkI16 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_i_16_reducer::DeleteAllPkI16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkI256 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_i_256_reducer::DeleteAllPkI256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkI32 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_i_32_reducer::DeleteAllPkI32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkI64 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_i_64_reducer::DeleteAllPkI64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkI8 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_i_8_reducer::DeleteAllPkI8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkIdentity { i, data } => { + __sats::bsatn::to_vec(&delete_all_pk_identity_reducer::DeleteAllPkIdentityArgs { + i: i.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkString { s, data } => { + __sats::bsatn::to_vec(&delete_all_pk_string_reducer::DeleteAllPkStringArgs { + s: s.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkU128 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_u_128_reducer::DeleteAllPkU128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkU16 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_u_16_reducer::DeleteAllPkU16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkU256 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_u_256_reducer::DeleteAllPkU256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkU32 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_u_32_reducer::DeleteAllPkU32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkU32Two { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_u_32_two_reducer::DeleteAllPkU32TwoArgs { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkU64 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_u_64_reducer::DeleteAllPkU64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkU8 { n, data } => { + __sats::bsatn::to_vec(&delete_all_pk_u_8_reducer::DeleteAllPkU8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllPkUuid { u, data } => { + __sats::bsatn::to_vec(&delete_all_pk_uuid_reducer::DeleteAllPkUuidArgs { + u: u.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueBool { b, data } => { + __sats::bsatn::to_vec(&delete_all_unique_bool_reducer::DeleteAllUniqueBoolArgs { + b: b.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueConnectionId { a, data } => __sats::bsatn::to_vec( + &delete_all_unique_connection_id_reducer::DeleteAllUniqueConnectionIdArgs { + a: a.clone(), + data: data.clone(), + }, + ), + Reducer::DeleteAllUniqueI128 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_i_128_reducer::DeleteAllUniqueI128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueI16 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_i_16_reducer::DeleteAllUniqueI16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueI256 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_i_256_reducer::DeleteAllUniqueI256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueI32 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_i_32_reducer::DeleteAllUniqueI32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueI64 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_i_64_reducer::DeleteAllUniqueI64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueI8 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_i_8_reducer::DeleteAllUniqueI8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueIdentity { i, data } => { + __sats::bsatn::to_vec(&delete_all_unique_identity_reducer::DeleteAllUniqueIdentityArgs { + i: i.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueString { s, data } => { + __sats::bsatn::to_vec(&delete_all_unique_string_reducer::DeleteAllUniqueStringArgs { + s: s.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueU128 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_u_128_reducer::DeleteAllUniqueU128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueU16 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_u_16_reducer::DeleteAllUniqueU16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueU256 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_u_256_reducer::DeleteAllUniqueU256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueU32 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_u_32_reducer::DeleteAllUniqueU32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueU64 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_u_64_reducer::DeleteAllUniqueU64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueU8 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_u_8_reducer::DeleteAllUniqueU8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueUuid { u, data } => { + __sats::bsatn::to_vec(&delete_all_unique_uuid_reducer::DeleteAllUniqueUuidArgs { + u: u.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllVecBool { b } => { + __sats::bsatn::to_vec(&delete_all_vec_bool_reducer::DeleteAllVecBoolArgs { b: b.clone() }) + } + Reducer::DeleteAllVecByteStruct { s } => { + __sats::bsatn::to_vec(&delete_all_vec_byte_struct_reducer::DeleteAllVecByteStructArgs { s: s.clone() }) + } + Reducer::DeleteAllVecEnumWithPayload { e } => __sats::bsatn::to_vec( + &delete_all_vec_enum_with_payload_reducer::DeleteAllVecEnumWithPayloadArgs { e: e.clone() }, + ), + Reducer::DeleteAllVecEveryPrimitiveStruct { s } => __sats::bsatn::to_vec( + &delete_all_vec_every_primitive_struct_reducer::DeleteAllVecEveryPrimitiveStructArgs { s: s.clone() }, + ), + Reducer::DeleteAllVecEveryVecStruct { s } => __sats::bsatn::to_vec( + &delete_all_vec_every_vec_struct_reducer::DeleteAllVecEveryVecStructArgs { s: s.clone() }, + ), + Reducer::DeleteAllVecF32 { f } => { + __sats::bsatn::to_vec(&delete_all_vec_f_32_reducer::DeleteAllVecF32Args { f: f.clone() }) + } + Reducer::DeleteAllVecF64 { f } => { + __sats::bsatn::to_vec(&delete_all_vec_f_64_reducer::DeleteAllVecF64Args { f: f.clone() }) + } + Reducer::DeleteAllVecI128 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_i_128_reducer::DeleteAllVecI128Args { n: n.clone() }) + } + Reducer::DeleteAllVecI16 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_i_16_reducer::DeleteAllVecI16Args { n: n.clone() }) + } + Reducer::DeleteAllVecI256 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_i_256_reducer::DeleteAllVecI256Args { n: n.clone() }) + } + Reducer::DeleteAllVecI32 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_i_32_reducer::DeleteAllVecI32Args { n: n.clone() }) + } + Reducer::DeleteAllVecI64 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_i_64_reducer::DeleteAllVecI64Args { n: n.clone() }) + } + Reducer::DeleteAllVecI8 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_i_8_reducer::DeleteAllVecI8Args { n: n.clone() }) + } + Reducer::DeleteAllVecIdentity { i } => { + __sats::bsatn::to_vec(&delete_all_vec_identity_reducer::DeleteAllVecIdentityArgs { i: i.clone() }) + } + Reducer::DeleteAllVecSimpleEnum { e } => { + __sats::bsatn::to_vec(&delete_all_vec_simple_enum_reducer::DeleteAllVecSimpleEnumArgs { e: e.clone() }) + } + Reducer::DeleteAllVecString { s } => { + __sats::bsatn::to_vec(&delete_all_vec_string_reducer::DeleteAllVecStringArgs { s: s.clone() }) + } + Reducer::DeleteAllVecTimestamp { t } => { + __sats::bsatn::to_vec(&delete_all_vec_timestamp_reducer::DeleteAllVecTimestampArgs { t: t.clone() }) + } + Reducer::DeleteAllVecU128 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_u_128_reducer::DeleteAllVecU128Args { n: n.clone() }) + } + Reducer::DeleteAllVecU16 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_u_16_reducer::DeleteAllVecU16Args { n: n.clone() }) + } + Reducer::DeleteAllVecU256 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_u_256_reducer::DeleteAllVecU256Args { n: n.clone() }) + } + Reducer::DeleteAllVecU32 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_u_32_reducer::DeleteAllVecU32Args { n: n.clone() }) + } + Reducer::DeleteAllVecU64 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_u_64_reducer::DeleteAllVecU64Args { n: n.clone() }) + } + Reducer::DeleteAllVecU8 { n } => { + __sats::bsatn::to_vec(&delete_all_vec_u_8_reducer::DeleteAllVecU8Args { n: n.clone() }) + } + Reducer::DeleteAllVecUnitStruct { s } => { + __sats::bsatn::to_vec(&delete_all_vec_unit_struct_reducer::DeleteAllVecUnitStructArgs { s: s.clone() }) + } + Reducer::DeleteAllVecUuid { u } => { + __sats::bsatn::to_vec(&delete_all_vec_uuid_reducer::DeleteAllVecUuidArgs { u: u.clone() }) + } Reducer::DeleteFromBtreeU32 { rows } => { __sats::bsatn::to_vec(&delete_from_btree_u_32_reducer::DeleteFromBtreeU32Args { rows: rows.clone() }) } @@ -2445,9 +3407,6 @@ impl __sdk::Reducer for Reducer { __sats::bsatn::to_vec(&insert_vec_uuid_reducer::InsertVecUuidArgs { u: u.clone() }) } Reducer::NoOpSucceeds => __sats::bsatn::to_vec(&no_op_succeeds_reducer::NoOpSucceedsArgs {}), - Reducer::SendScheduledMessage { arg } => { - __sats::bsatn::to_vec(&send_scheduled_message_reducer::SendScheduledMessageArgs { arg: arg.clone() }) - } Reducer::SortedUuidsInsert => __sats::bsatn::to_vec(&sorted_uuids_insert_reducer::SortedUuidsInsertArgs {}), Reducer::UpdateIndexedSimpleEnum { a, b } => { __sats::bsatn::to_vec(&update_indexed_simple_enum_reducer::UpdateIndexedSimpleEnumArgs { @@ -2654,8 +3613,6 @@ impl __sdk::Reducer for Reducer { pub struct DbUpdate { btree_u_32: __sdk::TableUpdate, indexed_simple_enum: __sdk::TableUpdate, - indexed_table: __sdk::TableUpdate, - indexed_table_2: __sdk::TableUpdate, large_table: __sdk::TableUpdate, one_bool: __sdk::TableUpdate, one_byte_struct: __sdk::TableUpdate, @@ -2775,12 +3732,6 @@ impl TryFrom<__ws::v2::TransactionUpdate> for DbUpdate { "indexed_simple_enum" => db_update .indexed_simple_enum .append(indexed_simple_enum_table::parse_table_update(table_update)?), - "indexed_table" => db_update - .indexed_table - .append(indexed_table_table::parse_table_update(table_update)?), - "indexed_table_2" => db_update - .indexed_table_2 - .append(indexed_table_2_table::parse_table_update(table_update)?), "large_table" => db_update .large_table .append(large_table_table::parse_table_update(table_update)?), @@ -3111,8 +4062,6 @@ impl __sdk::DbUpdate for DbUpdate { diff.btree_u_32 = cache.apply_diff_to_table::("btree_u_32", &self.btree_u_32); diff.indexed_simple_enum = cache.apply_diff_to_table::("indexed_simple_enum", &self.indexed_simple_enum); - diff.indexed_table = cache.apply_diff_to_table::("indexed_table", &self.indexed_table); - diff.indexed_table_2 = cache.apply_diff_to_table::("indexed_table_2", &self.indexed_table_2); diff.large_table = cache.apply_diff_to_table::("large_table", &self.large_table); diff.one_bool = cache.apply_diff_to_table::("one_bool", &self.one_bool); diff.one_byte_struct = cache.apply_diff_to_table::("one_byte_struct", &self.one_byte_struct); @@ -3300,12 +4249,6 @@ impl __sdk::DbUpdate for DbUpdate { "indexed_simple_enum" => db_update .indexed_simple_enum .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), - "indexed_table" => db_update - .indexed_table - .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), - "indexed_table_2" => db_update - .indexed_table_2 - .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), "large_table" => db_update .large_table .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), @@ -3638,12 +4581,6 @@ impl __sdk::DbUpdate for DbUpdate { "indexed_simple_enum" => db_update .indexed_simple_enum .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), - "indexed_table" => db_update - .indexed_table - .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), - "indexed_table_2" => db_update - .indexed_table_2 - .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), "large_table" => db_update .large_table .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), @@ -3974,8 +4911,6 @@ impl __sdk::DbUpdate for DbUpdate { pub struct AppliedDiff<'r> { btree_u_32: __sdk::TableAppliedDiff<'r, BTreeU32>, indexed_simple_enum: __sdk::TableAppliedDiff<'r, IndexedSimpleEnum>, - indexed_table: __sdk::TableAppliedDiff<'r, IndexedTable>, - indexed_table_2: __sdk::TableAppliedDiff<'r, IndexedTable2>, large_table: __sdk::TableAppliedDiff<'r, LargeTable>, one_bool: __sdk::TableAppliedDiff<'r, OneBool>, one_byte_struct: __sdk::TableAppliedDiff<'r, OneByteStruct>, @@ -4096,8 +5031,6 @@ impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> { &self.indexed_simple_enum, event, ); - callbacks.invoke_table_row_callbacks::("indexed_table", &self.indexed_table, event); - callbacks.invoke_table_row_callbacks::("indexed_table_2", &self.indexed_table_2, event); callbacks.invoke_table_row_callbacks::("large_table", &self.large_table, event); callbacks.invoke_table_row_callbacks::("one_bool", &self.one_bool, event); callbacks.invoke_table_row_callbacks::("one_byte_struct", &self.one_byte_struct, event); @@ -4914,8 +5847,6 @@ impl __sdk::SpacetimeModule for RemoteModule { fn register_tables(client_cache: &mut __sdk::ClientCache) { btree_u_32_table::register_table(client_cache); indexed_simple_enum_table::register_table(client_cache); - indexed_table_table::register_table(client_cache); - indexed_table_2_table::register_table(client_cache); large_table_table::register_table(client_cache); one_bool_table::register_table(client_cache); one_byte_struct_table::register_table(client_cache); @@ -5025,8 +5956,6 @@ impl __sdk::SpacetimeModule for RemoteModule { const ALL_TABLE_NAMES: &'static [&'static str] = &[ "btree_u_32", "indexed_simple_enum", - "indexed_table", - "indexed_table_2", "large_table", "one_bool", "one_byte_struct",