diff --git a/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h b/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h index b25e5cb44bd..728987b15c9 100644 --- a/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h +++ b/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h @@ -210,21 +210,30 @@ struct MultiColumnIndexTag { // Constraint Concepts // ============================================================================= +namespace detail { + template + struct filterable_value_impl + : std::bool_constant< + std::integral || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::is_enum_v> {}; + + template + struct filterable_value_impl> : filterable_value_impl> {}; +} + template -concept FilterableValue = - std::integral || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::is_enum_v; +concept FilterableValue = detail::filterable_value_impl>::value; template concept AutoIncrementable = diff --git a/crates/bindings-csharp/Codegen.Tests/Tests.cs b/crates/bindings-csharp/Codegen.Tests/Tests.cs index 463958ef835..40c1502ad8b 100644 --- a/crates/bindings-csharp/Codegen.Tests/Tests.cs +++ b/crates/bindings-csharp/Codegen.Tests/Tests.cs @@ -354,6 +354,117 @@ public static void @params(ProcedureContext ctx) Assert.Empty(GetCompilationErrors(compilationAfterGen)); } + [Fact] + public static async Task NullableBTreeIndexesCompile() + { + var fixture = await Fixture.Compile("server"); + + const string source = """ + using SpacetimeDB; + + [SpacetimeDB.Table] + public partial struct NullableBTreeIndex + { + [SpacetimeDB.PrimaryKey] + public uint Id; + + [SpacetimeDB.Index.BTree] + public uint? AccountId; + + [SpacetimeDB.Reducer] + public static void TestNullableBTreeIndex(ReducerContext ctx) + { + _ = ctx.Db.NullableBTreeIndex.AccountId.Filter((uint?)null); + _ = ctx.Db.NullableBTreeIndex.AccountId.Filter((uint?)55); + _ = ctx.Db.NullableBTreeIndex.AccountId.Filter(new Bound(null, 99)); + } + } + + [SpacetimeDB.Table] + public partial struct NullableUniqueIndex + { + [SpacetimeDB.PrimaryKey] + public uint Id; + + [SpacetimeDB.Unique] + public uint? AccountId; + + [SpacetimeDB.Unique] + public string? Name; + + [SpacetimeDB.Unique] + public SpacetimeDB.Uuid? ExternalId; + + [SpacetimeDB.Reducer] + public static void TestNullableUniqueIndex(ReducerContext ctx) + { + _ = ctx.Db.NullableUniqueIndex.AccountId.Find((uint?)null); + _ = ctx.Db.NullableUniqueIndex.AccountId.Find((uint?)55); + _ = ctx.Db.NullableUniqueIndex.Name.Find((string?)null); + _ = ctx.Db.NullableUniqueIndex.Name.Find("name"); + _ = ctx.Db.NullableUniqueIndex.ExternalId.Find((SpacetimeDB.Uuid?)null); + _ = ctx.Db.NullableUniqueIndex.ExternalId.Find(SpacetimeDB.Uuid.NIL); + } + } + + [SpacetimeDB.Table] + public partial struct ExplicitNullableBTreeIndex + { + [SpacetimeDB.PrimaryKey] + public uint Id; + + [SpacetimeDB.Index.BTree] + public System.Nullable AccountId; + + [SpacetimeDB.Reducer] + public static void TestExplicitNullableBTreeIndex(ReducerContext ctx) + { + _ = ctx.Db.ExplicitNullableBTreeIndex.AccountId.Filter((uint?)null); + _ = ctx.Db.ExplicitNullableBTreeIndex.AccountId.Filter((uint?)55); + _ = ctx.Db.ExplicitNullableBTreeIndex.AccountId.Filter(new Bound(null, 99)); + } + } + + [SpacetimeDB.Table] + public partial struct ExplicitNullableUniqueIndex + { + [SpacetimeDB.PrimaryKey] + public uint Id; + + [SpacetimeDB.Unique] + public System.Nullable AccountId; + + [SpacetimeDB.Reducer] + public static void TestExplicitNullableUniqueIndex(ReducerContext ctx) + { + _ = ctx.Db.ExplicitNullableUniqueIndex.AccountId.Find((uint?)null); + _ = ctx.Db.ExplicitNullableUniqueIndex.AccountId.Find((uint?)55); + } + } + """; + + var parseOptions = new CSharpParseOptions(fixture.SampleCompilation.LanguageVersion); + var tree = CSharpSyntaxTree.ParseText(source, parseOptions, path: "NullableBTreeIndex.cs"); + var compilation = fixture.SampleCompilation.AddSyntaxTrees(tree); + + var driver = CSharpGeneratorDriver.Create( + [ + new SpacetimeDB.Codegen.Type().AsSourceGenerator(), + new SpacetimeDB.Codegen.Module().AsSourceGenerator(), + ], + driverOptions: new( + disabledOutputs: IncrementalGeneratorOutputKind.None, + trackIncrementalGeneratorSteps: true + ), + parseOptions: parseOptions + ); + + var runResult = driver.RunGenerators(compilation).GetRunResult(); + var compilationAfterGen = compilation.AddSyntaxTrees(runResult.GeneratedTrees); + + Assert.Empty(GetCompilationErrors(compilationAfterGen)); + } + [Fact] public static async Task TestDiagnostics() { diff --git a/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module#FFI.verified.cs b/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module#FFI.verified.cs index edb27202d22..7c9416faecc 100644 --- a/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module#FFI.verified.cs +++ b/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module#FFI.verified.cs @@ -1194,6 +1194,25 @@ public ulong Clear() => TestDefaultFieldValues, global::TestDefaultFieldValues >.DoClear(); + + public sealed class UniqueFieldUniqueIndex + : UniqueIndex< + TestDefaultFieldValues, + global::TestDefaultFieldValues, + int?, + SpacetimeDB.BSATN.ValueOption + > + { + internal UniqueFieldUniqueIndex() + : base("TestDefaultFieldValues_UniqueField_idx_btree") { } + + // Important: don't move this to the base class. + // C# generics don't play well with nullable types and can't accept both struct-type-based and class-type-based + // `globalName` in one generic definition, leading to buggy `Row?` expansion for either one or another. + public global::TestDefaultFieldValues? Find(int? key) => FindSingle(key); + } + + public UniqueFieldUniqueIndex UniqueField => new(); } public readonly struct TestDuplicateTableName @@ -2058,6 +2077,25 @@ public ulong Clear() => global::TestUniqueNotEquatable >.DoClear(); + public sealed class UniqueFieldUniqueIndex + : UniqueIndex< + TestUniqueNotEquatable, + global::TestUniqueNotEquatable, + int?, + SpacetimeDB.BSATN.ValueOption + > + { + internal UniqueFieldUniqueIndex() + : base("TestUniqueNotEquatable_UniqueField_idx_btree") { } + + // Important: don't move this to the base class. + // C# generics don't play well with nullable types and can't accept both struct-type-based and class-type-based + // `globalName` in one generic definition, leading to buggy `Row?` expansion for either one or another. + public global::TestUniqueNotEquatable? Find(int? key) => FindSingle(key); + } + + public UniqueFieldUniqueIndex UniqueField => new(); + public sealed class PrimaryKeyFieldUniqueIndex : UniqueIndex< TestUniqueNotEquatable, @@ -2890,6 +2928,22 @@ internal TestDefaultFieldValuesReadOnly() /// It also takes into account modifications by the current transaction. /// public ulong Count => DoCount(); + + public sealed class UniqueFieldIndex + : global::SpacetimeDB.Internal.ReadOnlyUniqueIndex< + global::SpacetimeDB.Internal.ViewHandles.TestDefaultFieldValuesReadOnly, + global::TestDefaultFieldValues, + int?, + SpacetimeDB.BSATN.ValueOption + > + { + internal UniqueFieldIndex() + : base("TestDefaultFieldValues_UniqueField_idx_btree") { } + + public global::TestDefaultFieldValues? Find(int? key) => FindSingle(key); + } + + public UniqueFieldIndex UniqueField => new(); } public sealed class TestDuplicateTableNameReadOnly @@ -3161,6 +3215,22 @@ internal TestUniqueNotEquatableReadOnly() /// public ulong Count => DoCount(); + public sealed class UniqueFieldIndex + : global::SpacetimeDB.Internal.ReadOnlyUniqueIndex< + global::SpacetimeDB.Internal.ViewHandles.TestUniqueNotEquatableReadOnly, + global::TestUniqueNotEquatable, + int?, + SpacetimeDB.BSATN.ValueOption + > + { + internal UniqueFieldIndex() + : base("TestUniqueNotEquatable_UniqueField_idx_btree") { } + + public global::TestUniqueNotEquatable? Find(int? key) => FindSingle(key); + } + + public UniqueFieldIndex UniqueField => new(); + public sealed class PrimaryKeyFieldIndex : global::SpacetimeDB.Internal.ReadOnlyUniqueIndex< global::SpacetimeDB.Internal.ViewHandles.TestUniqueNotEquatableReadOnly, diff --git a/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module.verified.txt b/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module.verified.txt index 5978d4485c2..212e1939f21 100644 --- a/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module.verified.txt +++ b/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module.verified.txt @@ -35,23 +35,6 @@ } }, {/* - [Unique] - public int? UniqueField; - ^^^^^^^^^^^ - -*/ - Message: Field UniqueField is marked as Unique but it has a type int? which is not an equatable primitive., - Severity: Error, - Descriptor: { - Id: STDB0003, - Title: Unique fields must be equatable, - MessageFormat: Field {0} is marked as Unique but it has a type {1} which is not an equatable primitive., - Category: SpacetimeDB, - DefaultSeverity: Error, - IsEnabledByDefault: true - } - }, - {/* [SpacetimeDB.Table] public partial record TestTableTaggedEnum : SpacetimeDB.TaggedEnum<(int X, int Y)> { } ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -69,23 +52,6 @@ public partial record TestTableTaggedEnum : SpacetimeDB.TaggedEnum<(int X, int Y } }, {/* - [Unique] - public int? UniqueField; - ^^^^^^^^^^^ - -*/ - Message: Field UniqueField is marked as Unique but it has a type int? which is not an equatable primitive., - Severity: Error, - Descriptor: { - Id: STDB0003, - Title: Unique fields must be equatable, - MessageFormat: Field {0} is marked as Unique but it has a type {1} which is not an equatable primitive., - Category: SpacetimeDB, - DefaultSeverity: Error, - IsEnabledByDefault: true - } - }, - {/* { [SpacetimeDB.Index.BTree(Accessor = "TestUnexpectedColumns", Columns = ["UnexpectedColumn"])] ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -626,4 +592,4 @@ public partial struct TestScheduleIssues } } ] -} +} \ No newline at end of file diff --git a/crates/bindings-csharp/Codegen/Module.cs b/crates/bindings-csharp/Codegen/Module.cs index f130a3efb05..3f24c7821cc 100644 --- a/crates/bindings-csharp/Codegen/Module.cs +++ b/crates/bindings-csharp/Codegen/Module.cs @@ -160,9 +160,22 @@ public static bool IsNoPayloadEnum(ITypeSymbol type) && variants.All(field => field.Type.ToString() == "SpacetimeDB.Unit"); } - public static bool IsEquatable(ITypeSymbol type) => - ( - IsInteger(type) + private static ITypeSymbol UnwrapNullable(ITypeSymbol type) => + type switch + { + INamedTypeSymbol + { + OriginalDefinition.SpecialType: SpecialType.System_Nullable_T + } nullable => nullable.TypeArguments[0], + _ when type.NullableAnnotation == NullableAnnotation.Annotated => + type.WithNullableAnnotation(NullableAnnotation.None), + _ => type, + }; + + public static bool IsEquatable(ITypeSymbol type) + { + type = UnwrapNullable(type); + return IsInteger(type) || IsNoPayloadEnum(type) || type.SpecialType switch { @@ -173,9 +186,8 @@ public static bool IsEquatable(ITypeSymbol type) => or "SpacetimeDB.Timestamp" or "SpacetimeDB.Uuid", _ => false, - } - ) - && type.NullableAnnotation != NullableAnnotation.Annotated; + }; + } } /// diff --git a/crates/bindings-typescript/src/lib/type_builders.test-d.ts b/crates/bindings-typescript/src/lib/type_builders.test-d.ts index bae3089e145..93b7fd8e3ec 100644 --- a/crates/bindings-typescript/src/lib/type_builders.test-d.ts +++ b/crates/bindings-typescript/src/lib/type_builders.test-d.ts @@ -45,6 +45,27 @@ const _rowOptionOptionalSome: RowOptionOptional = { foo: 'hello', }; +// Optional columns whose inner type is filterable may be indexed and unique. +// eslint-disable-next-line @typescript-eslint/no-unused-vars +const rowOptionIndex = { + id: t.u64(), + optionalId: t.option(t.u64()).index('btree').unique(), +}; +type RowOptionIndex = InferTypeOfRow; +// eslint-disable-next-line @typescript-eslint/no-unused-vars +const _rowOptionIndexNone: RowOptionIndex = { + id: 1n, + optionalId: undefined, +}; +// eslint-disable-next-line @typescript-eslint/no-unused-vars +const _rowOptionIndexSome: RowOptionIndex = { + id: 2n, + optionalId: 1n, +}; + +// @ts-expect-error optional arrays are not filterable and cannot be indexed. +t.option(t.array(t.u64())).index('btree'); + // Test that a row must not allow non-TypeBuilder or ColumnBuilder values // eslint-disable-next-line @typescript-eslint/no-unused-vars const row2 = { diff --git a/crates/bindings-typescript/src/lib/type_builders.ts b/crates/bindings-typescript/src/lib/type_builders.ts index 136e040a2b6..42c37e3caa1 100644 --- a/crates/bindings-typescript/src/lib/type_builders.ts +++ b/crates/bindings-typescript/src/lib/type_builders.ts @@ -323,6 +323,18 @@ interface Indexable< ): ColumnBuilder>; } +type IndexableBuilder> = Value & + Indexable< + InferTypeOfTypeBuilder, + InferSpacetimeTypeOfTypeBuilder + >; + +type UniqueableBuilder> = Value & + Uniqueable< + InferTypeOfTypeBuilder, + InferSpacetimeTypeOfTypeBuilder + >; + /** * Interface for types that can be converted into a column builder with auto-increment metadata. * @@ -1376,6 +1388,36 @@ export class OptionBuilder> super(Option.getAlgebraicType(value.algebraicType)); this.value = value; } + index( + this: OptionBuilder> + ): OptionColumnBuilder< + Value, + SetField + >; + index>( + this: OptionBuilder>, + algorithm: N + ): OptionColumnBuilder>; + index( + this: OptionBuilder>, + algorithm: IndexTypes = 'btree' + ): OptionColumnBuilder< + Value, + SetField + > { + return new OptionColumnBuilder( + this, + set(defaultMetadata, { indexType: algorithm }) + ); + } + unique( + this: OptionBuilder> + ): OptionColumnBuilder> { + return new OptionColumnBuilder( + this, + set(defaultMetadata, { isUnique: true }) + ); + } default( value: InferTypeOfTypeBuilder | undefined ): OptionColumnBuilder< @@ -3161,6 +3203,30 @@ export class OptionColumnBuilder< OptionAlgebraicType> > { + index( + this: OptionColumnBuilder, M> + ): OptionColumnBuilder>; + index>( + this: OptionColumnBuilder, M>, + algorithm: N + ): OptionColumnBuilder>; + index( + this: OptionColumnBuilder, M>, + algorithm: IndexTypes = 'btree' + ): OptionColumnBuilder> { + return new OptionColumnBuilder( + this.typeBuilder, + set(this.columnMetadata, { indexType: algorithm }) + ); + } + unique( + this: OptionColumnBuilder, M> + ): OptionColumnBuilder> { + return new OptionColumnBuilder( + this.typeBuilder, + set(this.columnMetadata, { isUnique: true }) + ); + } default( value: InferTypeOfTypeBuilder | undefined ): OptionColumnBuilder< diff --git a/crates/bindings-typescript/src/sdk/table_cache.ts b/crates/bindings-typescript/src/sdk/table_cache.ts index 543d3fb78ed..5129a8ee968 100644 --- a/crates/bindings-typescript/src/sdk/table_cache.ts +++ b/crates/bindings-typescript/src/sdk/table_cache.ts @@ -37,13 +37,29 @@ export type PendingCallback = { cb: () => void; }; -// Strict scalar compare for index term values. -const scalarCompare = (x: any, y: any): number => { +const isOptionNone = (value: any): boolean => + value === null || value === undefined; + +const compareIndexTerm = (x: any, y: any): number => { + if (isOptionNone(x) && isOptionNone(y)) return 0; + if (isOptionNone(x)) return -1; + if (isOptionNone(y)) return 1; if (x === y) return 0; + if (typeof x?.compareTo === 'function') return x.compareTo(y); // Compare booleans/numbers/bigints/strings with JS ordering. return x < y ? -1 : 1; }; +const indexTermEqual = (x: any, y: any): boolean => + compareIndexTerm(x, y) === 0 || deepEqual(x, y); + +const indexKeyEqual = ( + actual: readonly unknown[], + expected: readonly unknown[] +): boolean => + actual.length === expected.length && + actual.every((value, i) => indexTermEqual(value, expected[i])); + export type TableIndexView< RemoteModule extends UntypedRemoteModule, TableName extends TableNamesOf, @@ -143,7 +159,7 @@ export class TableCacheImpl< const prefixLen = Math.max(0, arr.length - 1); // Check equality over the prefix (all but the last provided element) for (let i = 0; i < prefixLen; i++) { - if (!deepEqual(key[i], arr[i])) return false; + if (!indexTermEqual(key[i], arr[i])) return false; } const lastProvided = arr[arr.length - 1]; @@ -162,14 +178,14 @@ export class TableCacheImpl< // Lower bound if (from.tag !== 'unbounded') { - const c = scalarCompare(kLast, from.value); + const c = compareIndexTerm(kLast, from.value); if (c < 0) return false; if (c === 0 && from.tag === 'excluded') return false; } // Upper bound if (to.tag !== 'unbounded') { - const c = scalarCompare(kLast, to.value); + const c = compareIndexTerm(kLast, to.value); if (c > 0) return false; if (c === 0 && to.tag === 'excluded') return false; } @@ -179,7 +195,7 @@ export class TableCacheImpl< return true; } else { // Equality on the last provided element - if (!deepEqual(kLast, lastProvided)) return false; + if (!indexTermEqual(kLast, lastProvided)) return false; // Any remaining columns are unconstrained (prefix equality only). return true; } @@ -201,7 +217,7 @@ export class TableCacheImpl< // For unique btree, caller supplies the *full* key (tuple if multi-col). const expected = Array.isArray(colVal) ? colVal : [colVal]; for (const row of self.iter()) { - if (deepEqual(getKey(row), expected)) return row; + if (indexKeyEqual(getKey(row), expected)) return row; } return null; }, diff --git a/crates/bindings-typescript/tests/table_cache_resolved_indexes.test.ts b/crates/bindings-typescript/tests/table_cache_resolved_indexes.test.ts index 1e67cb418e5..28aeeaa8e0f 100644 --- a/crates/bindings-typescript/tests/table_cache_resolved_indexes.test.ts +++ b/crates/bindings-typescript/tests/table_cache_resolved_indexes.test.ts @@ -3,6 +3,7 @@ import { ModuleContext, tablesToSchema } from '../src/lib/schema'; import { table } from '../src/lib/table'; import { TableCacheImpl } from '../src/sdk/table_cache'; import { t } from '../src/lib/type_builders'; +import { Range } from '../src/server/range'; describe('table cache resolved indexes', () => { it('builds index accessors from resolvedIndexes (field-level + table-level)', () => { @@ -68,4 +69,64 @@ describe('table cache resolved indexes', () => { expect(typeof byTeamAndLevel?.filter).toBe('function'); expect(Array.from(byTeamAndLevel.filter(['red', 1]))).toEqual([rows[0]]); }); + + it('treats null and undefined as option none in btree cache filters', () => { + const account = table( + { + name: 'account', + indexes: [ + { + accessor: 'linkedId', + algorithm: 'btree', + columns: ['linkedId'] as const, + }, + ] as const, + }, + { + id: t.u32(), + linkedId: t.option(t.u32()).index('btree'), + uniqueLinkedId: t.option(t.u32()).unique(), + } + ); + + const schemaDef = tablesToSchema(new ModuleContext(), { account }); + const accountDef = schemaDef.tables.account; + const tableCache = new TableCacheImpl(accountDef as any); + + const rows = [ + { id: 1, linkedId: undefined, uniqueLinkedId: undefined }, + { id: 2, linkedId: null, uniqueLinkedId: 7 }, + { id: 3, linkedId: 5, uniqueLinkedId: 8 }, + { id: 4, linkedId: 9, uniqueLinkedId: 9 }, + ]; + + const callbacks = tableCache.applyOperations( + rows.map(row => ({ + type: 'insert' as const, + rowId: row.id, + row, + })), + {} + ); + callbacks.forEach(cb => cb.cb()); + + const linkedId = (tableCache as any).linkedId; + const uniqueLinkedId = (tableCache as any).uniqueLinkedId; + + expect(uniqueLinkedId.find(null)?.id).toEqual(1); + expect(Array.from(linkedId.filter(null)).map(row => row.id)).toEqual([ + 1, 2, + ]); + expect(Array.from(linkedId.filter(5)).map(row => row.id)).toEqual([3]); + expect( + Array.from( + linkedId.filter( + new Range( + { tag: 'included', value: null }, + { tag: 'included', value: 5 } + ) + ) + ).map(row => row.id) + ).toEqual([1, 2, 3]); + }); }); diff --git a/crates/bindings/tests/pass/option-index-filter.rs b/crates/bindings/tests/pass/option-index-filter.rs new file mode 100644 index 00000000000..ee719f77f32 --- /dev/null +++ b/crates/bindings/tests/pass/option-index-filter.rs @@ -0,0 +1,37 @@ +#[spacetimedb::table(accessor = option_index_args)] +struct OptionIndexArgs { + #[primary_key] + id: u64, + #[index(btree)] + option_u64: Option, +} + +#[spacetimedb::table(accessor = compound_option_index_args, index(accessor = by_id_and_option, btree(columns = [id, option_u64])))] +struct CompoundOptionIndexArgs { + id: u64, + option_u64: Option, +} + +#[spacetimedb::reducer] +fn option_index_filters_compile(ctx: &spacetimedb::ReducerContext) { + let some_u64 = Some(55u64); + let none_u64: Option = None; + + let _ = ctx.db.option_index_args().option_u64().filter(some_u64); + let _ = ctx.db.option_index_args().option_u64().filter(none_u64); + let _ = ctx.db.option_index_args().option_u64().filter(Some(1u64)..Some(99u64)); + let _ = ctx.db.option_index_args().option_u64().filter(None..=Some(99u64)); + + let _ = ctx + .db + .compound_option_index_args() + .by_id_and_option() + .filter((1u64, Some(55u64))); + let _ = ctx + .db + .compound_option_index_args() + .by_id_and_option() + .filter((1u64, None..=Some(99u64))); +} + +fn main() {} diff --git a/crates/codegen/src/csharp.rs b/crates/codegen/src/csharp.rs index 76907815898..9934600185d 100644 --- a/crates/codegen/src/csharp.rs +++ b/crates/codegen/src/csharp.rs @@ -561,10 +561,17 @@ impl Lang for Csharp<'_> { (csharp_field_name_pascal, csharp_field_type) }; - let (row_to_key, key_type) = match columns.as_singleton() { + let (row_to_key, key_type, nullable_single_column) = match columns.as_singleton() { Some(col_pos) => { - let (field_name, field_type) = get_csharp_field_name_and_type(col_pos); - (format!("row.{field_name}"), field_type.to_string()) + let (field_name, field_type) = &product_type.elements[col_pos.idx()]; + let csharp_field_name_pascal = field_name.deref().to_case(Case::Pascal); + let csharp_field_type = ty_fmt(module, field_type).to_string(); + let nullable_single_column = matches!(field_type, AlgebraicTypeUse::Option(_)); + ( + format!("row.{csharp_field_name_pascal}"), + csharp_field_type, + nullable_single_column, + ) } None => { let mut key_accessors = Vec::new(); @@ -576,6 +583,7 @@ impl Lang for Csharp<'_> { ( format!("({})", key_accessors.join(", ")), format!("({})", key_type_elems.join(", ")), + false, ) } }; @@ -585,10 +593,18 @@ impl Lang for Csharp<'_> { let mut csharp_index_class_name = csharp_index_name.clone(); let csharp_index_base_class_name = if schema.is_unique(&columns) { csharp_index_class_name += "UniqueIndex"; - "UniqueIndexBase" + if nullable_single_column { + "NullableUniqueIndexBase" + } else { + "UniqueIndexBase" + } } else { csharp_index_class_name += "Index"; - "BTreeIndexBase" + if nullable_single_column { + "NullableBTreeIndexBase" + } else { + "BTreeIndexBase" + } }; writeln!( diff --git a/crates/codegen/src/util.rs b/crates/codegen/src/util.rs index a13a7ff2aba..3f81f12a4d3 100644 --- a/crates/codegen/src/util.rs +++ b/crates/codegen/src/util.rs @@ -85,11 +85,18 @@ pub(super) fn type_ref_name(module: &ModuleDef, typeref: AlgebraicTypeRef) -> St pub(super) fn is_type_filterable(typespace: &TypespaceForGenerate, ty: &AlgebraicTypeUse) -> bool { match ty { AlgebraicTypeUse::Primitive(prim) => !matches!(prim, PrimitiveType::F32 | PrimitiveType::F64), - AlgebraicTypeUse::String | AlgebraicTypeUse::Identity | AlgebraicTypeUse::ConnectionId => true, + AlgebraicTypeUse::String + | AlgebraicTypeUse::Identity + | AlgebraicTypeUse::ConnectionId + | AlgebraicTypeUse::Uuid => true, // Sum types with all unit variants: AlgebraicTypeUse::Never => true, - AlgebraicTypeUse::Option(inner) => matches!(&**inner, AlgebraicTypeUse::Unit), + // At the top level, the only case where a ref can appear that should be filterable is a simple enum. AlgebraicTypeUse::Ref(r) => typespace[r].is_plain_enum(), + + // Options of filterable types: + AlgebraicTypeUse::Option(inner) => is_type_filterable(typespace, inner), + _ => false, } } diff --git a/crates/lib/src/filterable_value.rs b/crates/lib/src/filterable_value.rs index 6f7accbf3e9..07038c00491 100644 --- a/crates/lib/src/filterable_value.rs +++ b/crates/lib/src/filterable_value.rs @@ -118,6 +118,11 @@ impl_filterable_value! { // &[u8] => Vec, } +impl Private for Option {} +impl FilterableValue for Option { + type Column = Option; +} + /// Marker trait for column types supported as procedural view primary keys. #[doc(hidden)] #[diagnostic::on_unimplemented( diff --git a/modules/sdk-test-cpp/src/lib.cpp b/modules/sdk-test-cpp/src/lib.cpp index 6a238395537..fd8c62c28b6 100644 --- a/modules/sdk-test-cpp/src/lib.cpp +++ b/modules/sdk-test-cpp/src/lib.cpp @@ -490,6 +490,95 @@ SPACETIMEDB_STRUCT(UniqueConnectionId, a, data) SPACETIMEDB_TABLE(UniqueConnectionId, unique_connection_id, Public) FIELD_Unique(unique_connection_id, a); +// ============================================================================= +// UNIQUE OPTIONAL CONSTRAINT TABLES - Matching Rust's UniqueOptionXXX pattern +// ============================================================================= + +struct UniqueOptionU8 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU8, n, data) +SPACETIMEDB_TABLE(UniqueOptionU8, unique_option_u8, Public) +FIELD_Unique(unique_option_u8, n); + +struct UniqueOptionU16 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU16, n, data) +SPACETIMEDB_TABLE(UniqueOptionU16, unique_option_u16, Public) +FIELD_Unique(unique_option_u16, n); + +struct UniqueOptionU32 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU32, n, data) +SPACETIMEDB_TABLE(UniqueOptionU32, unique_option_u32, Public) +FIELD_Unique(unique_option_u32, n); + +struct UniqueOptionU64 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU64, n, data) +SPACETIMEDB_TABLE(UniqueOptionU64, unique_option_u64, Public) +FIELD_Unique(unique_option_u64, n); + +struct UniqueOptionU128 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU128, n, data) +SPACETIMEDB_TABLE(UniqueOptionU128, unique_option_u128, Public) +FIELD_Unique(unique_option_u128, n); + +struct UniqueOptionU256 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU256, n, data) +SPACETIMEDB_TABLE(UniqueOptionU256, unique_option_u256, Public) +FIELD_Unique(unique_option_u256, n); + +struct UniqueOptionI8 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI8, n, data) +SPACETIMEDB_TABLE(UniqueOptionI8, unique_option_i8, Public) +FIELD_Unique(unique_option_i8, n); + +struct UniqueOptionI16 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI16, n, data) +SPACETIMEDB_TABLE(UniqueOptionI16, unique_option_i16, Public) +FIELD_Unique(unique_option_i16, n); + +struct UniqueOptionI32 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI32, n, data) +SPACETIMEDB_TABLE(UniqueOptionI32, unique_option_i32, Public) +FIELD_Unique(unique_option_i32, n); + +struct UniqueOptionI64 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI64, n, data) +SPACETIMEDB_TABLE(UniqueOptionI64, unique_option_i64, Public) +FIELD_Unique(unique_option_i64, n); + +struct UniqueOptionI128 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI128, n, data) +SPACETIMEDB_TABLE(UniqueOptionI128, unique_option_i128, Public) +FIELD_Unique(unique_option_i128, n); + +struct UniqueOptionI256 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI256, n, data) +SPACETIMEDB_TABLE(UniqueOptionI256, unique_option_i256, Public) +FIELD_Unique(unique_option_i256, n); + +struct UniqueOptionBool { std::optional b; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionBool, b, data) +SPACETIMEDB_TABLE(UniqueOptionBool, unique_option_bool, Public) +FIELD_Unique(unique_option_bool, b); + +struct UniqueOptionString { std::optional s; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionString, s, data) +SPACETIMEDB_TABLE(UniqueOptionString, unique_option_string, Public) +FIELD_Unique(unique_option_string, s); + +struct UniqueOptionIdentity { std::optional i; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionIdentity, i, data) +SPACETIMEDB_TABLE(UniqueOptionIdentity, unique_option_identity, Public) +FIELD_Unique(unique_option_identity, i); + +struct UniqueOptionConnectionId { std::optional a; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionConnectionId, a, data) +SPACETIMEDB_TABLE(UniqueOptionConnectionId, unique_option_connection_id, Public) +FIELD_Unique(unique_option_connection_id, a); + +struct UniqueOptionUuid { std::optional u; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionUuid, u, data) +SPACETIMEDB_TABLE(UniqueOptionUuid, unique_option_uuid, Public) +FIELD_Unique(unique_option_uuid, u); + // ============================================================================= // PRIMARY KEY TABLES - Matching Rust's PkXXX pattern // ============================================================================= @@ -693,100 +782,202 @@ SPACETIMEDB_REDUCER(insert_one_u8, ReducerContext ctx, uint8_t n) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u8, ReducerContext ctx, uint8_t n) +{ + ctx.db[one_u8].delete_by_value(OneU8{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u16, ReducerContext ctx, uint16_t n) { ctx.db[one_u16].insert(OneU16{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u16, ReducerContext ctx, uint16_t n) +{ + ctx.db[one_u16].delete_by_value(OneU16{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u32, ReducerContext ctx, uint32_t n) { ctx.db[one_u32].insert(OneU32{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u32, ReducerContext ctx, uint32_t n) +{ + ctx.db[one_u32].delete_by_value(OneU32{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u64, ReducerContext ctx, uint64_t n) { ctx.db[one_u64].insert(OneU64{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u64, ReducerContext ctx, uint64_t n) +{ + ctx.db[one_u64].delete_by_value(OneU64{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u128, ReducerContext ctx, u128 n) { ctx.db[one_u128].insert(OneU128{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u128, ReducerContext ctx, u128 n) +{ + ctx.db[one_u128].delete_by_value(OneU128{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u256, ReducerContext ctx, u256 n) { ctx.db[one_u256].insert(OneU256{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u256, ReducerContext ctx, u256 n) +{ + ctx.db[one_u256].delete_by_value(OneU256{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i8, ReducerContext ctx, int8_t n) { ctx.db[one_i8].insert(OneI8{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i8, ReducerContext ctx, int8_t n) +{ + ctx.db[one_i8].delete_by_value(OneI8{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i16, ReducerContext ctx, int16_t n) { ctx.db[one_i16].insert(OneI16{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i16, ReducerContext ctx, int16_t n) +{ + ctx.db[one_i16].delete_by_value(OneI16{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i32, ReducerContext ctx, int32_t n) { ctx.db[one_i32].insert(OneI32{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i32, ReducerContext ctx, int32_t n) +{ + ctx.db[one_i32].delete_by_value(OneI32{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i64, ReducerContext ctx, int64_t n) { ctx.db[one_i64].insert(OneI64{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i64, ReducerContext ctx, int64_t n) +{ + ctx.db[one_i64].delete_by_value(OneI64{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i128, ReducerContext ctx, i128 n) { ctx.db[one_i128].insert(OneI128{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i128, ReducerContext ctx, i128 n) +{ + ctx.db[one_i128].delete_by_value(OneI128{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i256, ReducerContext ctx, i256 n) { ctx.db[one_i256].insert(OneI256{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i256, ReducerContext ctx, i256 n) +{ + ctx.db[one_i256].delete_by_value(OneI256{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_bool, ReducerContext ctx, bool b) { ctx.db[one_bool].insert(OneBool{.b = b}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_bool, ReducerContext ctx, bool b) +{ + ctx.db[one_bool].delete_by_value(OneBool{.b = b}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_f32, ReducerContext ctx, float f) { ctx.db[one_f32].insert(OneF32{.f = f}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_f32, ReducerContext ctx, float f) +{ + ctx.db[one_f32].delete_by_value(OneF32{.f = f}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_f64, ReducerContext ctx, double f) { ctx.db[one_f64].insert(OneF64{.f = f}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_f64, ReducerContext ctx, double f) +{ + ctx.db[one_f64].delete_by_value(OneF64{.f = f}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_string, ReducerContext ctx, std::string s) { ctx.db[one_string].insert(OneString{.s = s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_string, ReducerContext ctx, std::string s) +{ + ctx.db[one_string].delete_by_value(OneString{.s = s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_identity, ReducerContext ctx, Identity i) { ctx.db[one_identity].insert(OneIdentity{.i = i}); return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_one_identity, ReducerContext ctx, Identity i) +{ + ctx.db[one_identity].delete_by_value(OneIdentity{.i = i}); + return Ok(); } SPACETIMEDB_REDUCER(insert_one_connection_id, ReducerContext ctx, ConnectionId a) @@ -799,6 +990,12 @@ SPACETIMEDB_REDUCER(insert_one_string, ReducerContext ctx, std::string s) { ctx.db[one_timestamp].insert(OneTimestamp{.t = t}); return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_one_timestamp, ReducerContext ctx, Timestamp t) +{ + ctx.db[one_timestamp].delete_by_value(OneTimestamp{.t = t}); + return Ok(); } SPACETIMEDB_REDUCER(insert_one_uuid, ReducerContext ctx, Uuid u) @@ -807,6 +1004,12 @@ SPACETIMEDB_REDUCER(insert_one_uuid, ReducerContext ctx, Uuid u) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_uuid, ReducerContext ctx, Uuid u) +{ + ctx.db[one_uuid].delete_by_value(OneUuid{.u = u}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_call_uuid_v4, ReducerContext ctx) { ctx.db[one_uuid].insert(OneUuid{.u = ctx.new_uuid_v4()}); @@ -825,12 +1028,24 @@ SPACETIMEDB_REDUCER(insert_one_simple_enum, ReducerContext ctx, SimpleEnum e) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_simple_enum, ReducerContext ctx, SimpleEnum e) +{ + ctx.db[one_simple_enum].delete_by_value(OneSimpleEnum{.e = e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_enum_with_payload, ReducerContext ctx, EnumWithPayload e) { ctx.db[one_enum_with_payload].insert(OneEnumWithPayload{e}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_enum_with_payload, ReducerContext ctx, EnumWithPayload e) +{ + ctx.db[one_enum_with_payload].delete_by_value(OneEnumWithPayload{e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_unit_struct, ReducerContext ctx, UnitStruct s) { fprintf(stdout, "SUCCESS: insert_one_unit_struct reducer called with UnitStruct\n"); @@ -838,22 +1053,46 @@ SPACETIMEDB_REDUCER(insert_one_unit_struct, ReducerContext ctx, UnitStruct s) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_unit_struct, ReducerContext ctx, UnitStruct s) +{ + ctx.db[one_unit_struct].delete_by_value(OneUnitStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_byte_struct, ReducerContext ctx, ByteStruct s) { ctx.db[one_byte_struct].insert(OneByteStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_byte_struct, ReducerContext ctx, ByteStruct s) +{ + ctx.db[one_byte_struct].delete_by_value(OneByteStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_every_primitive_struct, ReducerContext ctx, EveryPrimitiveStruct s) { ctx.db[one_every_primitive_struct].insert(OneEveryPrimitiveStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_every_primitive_struct, ReducerContext ctx, EveryPrimitiveStruct s) +{ + ctx.db[one_every_primitive_struct].delete_by_value(OneEveryPrimitiveStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_every_vec_struct, ReducerContext ctx, EveryVecStruct s) { ctx.db[one_every_vec_struct].insert(OneEveryVecStruct{s}); return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_one_every_vec_struct, ReducerContext ctx, EveryVecStruct s) +{ + ctx.db[one_every_vec_struct].delete_by_value(OneEveryVecStruct{s}); + return Ok(); } // ============================================================================= @@ -866,102 +1105,204 @@ SPACETIMEDB_REDUCER(insert_vec_u8, ReducerContext ctx, std::vector n) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u8, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u8].delete_by_value(VecU8{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u16, ReducerContext ctx, std::vector n) { ctx.db[vec_u16].insert(VecU16{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u16, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u16].delete_by_value(VecU16{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u32, ReducerContext ctx, std::vector n) { ctx.db[vec_u32].insert(VecU32{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u32, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u32].delete_by_value(VecU32{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u64, ReducerContext ctx, std::vector n) { ctx.db[vec_u64].insert(VecU64{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u64, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u64].delete_by_value(VecU64{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u128, ReducerContext ctx, std::vector n) { ctx.db[vec_u128].insert(VecU128{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u128, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u128].delete_by_value(VecU128{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u256, ReducerContext ctx, std::vector n) { ctx.db[vec_u256].insert(VecU256{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u256, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u256].delete_by_value(VecU256{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i8, ReducerContext ctx, std::vector n) { ctx.db[vec_i8].insert(VecI8{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i8, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i8].delete_by_value(VecI8{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i16, ReducerContext ctx, std::vector n) { ctx.db[vec_i16].insert(VecI16{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i16, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i16].delete_by_value(VecI16{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i32, ReducerContext ctx, std::vector n) { ctx.db[vec_i32].insert(VecI32{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i32, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i32].delete_by_value(VecI32{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i64, ReducerContext ctx, std::vector n) { ctx.db[vec_i64].insert(VecI64{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i64, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i64].delete_by_value(VecI64{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i128, ReducerContext ctx, std::vector n) { ctx.db[vec_i128].insert(VecI128{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i128, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i128].delete_by_value(VecI128{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i256, ReducerContext ctx, std::vector n) { ctx.db[vec_i256].insert(VecI256{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i256, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i256].delete_by_value(VecI256{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_bool, ReducerContext ctx, std::vector b) { ctx.db[vec_bool].insert(VecBool{b}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_bool, ReducerContext ctx, std::vector b) +{ + ctx.db[vec_bool].delete_by_value(VecBool{b}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_f32, ReducerContext ctx, std::vector f) { ctx.db[vec_f32].insert(VecF32{f}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_f32, ReducerContext ctx, std::vector f) +{ + ctx.db[vec_f32].delete_by_value(VecF32{f}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_f64, ReducerContext ctx, std::vector f) { ctx.db[vec_f64].insert(VecF64{f}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_f64, ReducerContext ctx, std::vector f) +{ + ctx.db[vec_f64].delete_by_value(VecF64{f}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_string, ReducerContext ctx, std::vector s) { ctx.db[vec_string].insert(VecString{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_string, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_string].delete_by_value(VecString{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_identity, ReducerContext ctx, std::vector i) { ctx.db[vec_identity].insert(VecIdentity{i}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_identity, ReducerContext ctx, std::vector i) +{ + ctx.db[vec_identity].delete_by_value(VecIdentity{i}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_connection_id, ReducerContext ctx, std::vector a) { ctx.db[vec_connection_id].insert(VecConnectionId{a}); @@ -974,46 +1315,94 @@ SPACETIMEDB_REDUCER(insert_vec_timestamp, ReducerContext ctx, std::vector t) +{ + ctx.db[vec_timestamp].delete_by_value(VecTimestamp{t}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_uuid, ReducerContext ctx, std::vector u) { ctx.db[vec_uuid].insert(VecUuid{u}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_uuid, ReducerContext ctx, std::vector u) +{ + ctx.db[vec_uuid].delete_by_value(VecUuid{u}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_simple_enum, ReducerContext ctx, std::vector e) { ctx.db[vec_simple_enum].insert(VecSimpleEnum{e}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_simple_enum, ReducerContext ctx, std::vector e) +{ + ctx.db[vec_simple_enum].delete_by_value(VecSimpleEnum{e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_enum_with_payload, ReducerContext ctx, std::vector e) { ctx.db[vec_enum_with_payload].insert(VecEnumWithPayload{e}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_enum_with_payload, ReducerContext ctx, std::vector e) +{ + ctx.db[vec_enum_with_payload].delete_by_value(VecEnumWithPayload{e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_unit_struct, ReducerContext ctx, std::vector s) { ctx.db[vec_unit_struct].insert(VecUnitStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_unit_struct, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_unit_struct].delete_by_value(VecUnitStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_byte_struct, ReducerContext ctx, std::vector s) { ctx.db[vec_byte_struct].insert(VecByteStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_byte_struct, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_byte_struct].delete_by_value(VecByteStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_every_primitive_struct, ReducerContext ctx, std::vector s) { ctx.db[vec_every_primitive_struct].insert(VecEveryPrimitiveStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_every_primitive_struct, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_every_primitive_struct].delete_by_value(VecEveryPrimitiveStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_every_vec_struct, ReducerContext ctx, std::vector s) { ctx.db[vec_every_vec_struct].insert(VecEveryVecStruct{s}); return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_vec_every_vec_struct, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_every_vec_struct].delete_by_value(VecEveryVecStruct{s}); + return Ok(); } // ============================================================================= @@ -1026,36 +1415,72 @@ SPACETIMEDB_REDUCER(insert_option_i32, ReducerContext ctx, std::optional n) +{ + ctx.db[option_i32].delete_by_value(OptionI32{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_string, ReducerContext ctx, std::optional s) { ctx.db[option_string].insert(OptionString{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_string, ReducerContext ctx, std::optional s) +{ + ctx.db[option_string].delete_by_value(OptionString{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_uuid, ReducerContext ctx, std::optional u) { ctx.db[option_uuid].insert(OptionUuid{u}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_uuid, ReducerContext ctx, std::optional u) +{ + ctx.db[option_uuid].delete_by_value(OptionUuid{u}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_identity, ReducerContext ctx, std::optional i) { ctx.db[option_identity].insert(OptionIdentity{i}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_identity, ReducerContext ctx, std::optional i) +{ + ctx.db[option_identity].delete_by_value(OptionIdentity{i}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_simple_enum, ReducerContext ctx, std::optional e) { ctx.db[option_simple_enum].insert(OptionSimpleEnum{e}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_simple_enum, ReducerContext ctx, std::optional e) +{ + ctx.db[option_simple_enum].delete_by_value(OptionSimpleEnum{e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_every_primitive_struct, ReducerContext ctx, std::optional s) { ctx.db[option_every_primitive_struct].insert(OptionEveryPrimitiveStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_every_primitive_struct, ReducerContext ctx, std::optional s) +{ + ctx.db[option_every_primitive_struct].delete_by_value(OptionEveryPrimitiveStruct{s}); + return Ok(); +} + // Complex nested optional type - NOW FIXED! SPACETIMEDB_REDUCER(insert_option_vec_option_i32, ReducerContext ctx, std::optional>> v) { @@ -1063,6 +1488,12 @@ SPACETIMEDB_REDUCER(insert_option_every_primitive_struct, ReducerContext ctx, st return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_vec_option_i32, ReducerContext ctx, std::optional>> v) +{ + ctx.db[option_vec_option_i32].delete_by_value(OptionVecOptionI32{v}); + return Ok(); +} + // ============================================================================= // RESULT TABLE REDUCERS - INSERT OPERATIONS // ============================================================================= @@ -1073,139 +1504,445 @@ SPACETIMEDB_REDUCER(insert_result_i32_string, ReducerContext ctx, Result r) +SPACETIMEDB_REDUCER(insert_result_string_i32, ReducerContext ctx, Result r) +{ + ctx.db[result_string_i32].insert(ResultStringI32{r}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_result_identity_string, ReducerContext ctx, Result r) +{ + ctx.db[result_identity_string].insert(ResultIdentityString{r}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_result_simple_enum_i32, ReducerContext ctx, Result r) +{ + ctx.db[result_simple_enum_i32].insert(ResultSimpleEnumI32{r}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_result_every_primitive_struct_string, ReducerContext ctx, Result r) +{ + ctx.db[result_every_primitive_struct_string].insert(ResultEveryPrimitiveStructString{r}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_result_vec_i32_string, ReducerContext ctx, Result, std::string> r) +{ + ctx.db[result_vec_i32_string].insert(ResultVecI32String{r}); + return Ok(); +} + +// ============================================================================= +// UNIQUE CONSTRAINT TABLE REDUCERS +// ============================================================================= + +SPACETIMEDB_REDUCER(insert_unique_u8, ReducerContext ctx, uint8_t n, int32_t data) +{ + ctx.db[unique_u8].insert(UniqueU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u8, ReducerContext ctx, uint8_t n, int32_t data) +{ + ctx.db[unique_u8].delete_by_value(UniqueU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u16, ReducerContext ctx, uint16_t n, int32_t data) +{ + ctx.db[unique_u16].insert(UniqueU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u16, ReducerContext ctx, uint16_t n, int32_t data) +{ + ctx.db[unique_u16].delete_by_value(UniqueU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u32, ReducerContext ctx, uint32_t n, int32_t data) +{ + ctx.db[unique_u32].insert(UniqueU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u32, ReducerContext ctx, uint32_t n, int32_t data) +{ + ctx.db[unique_u32].delete_by_value(UniqueU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u64, ReducerContext ctx, uint64_t n, int32_t data) +{ + ctx.db[unique_u64].insert(UniqueU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u64, ReducerContext ctx, uint64_t n, int32_t data) +{ + ctx.db[unique_u64].delete_by_value(UniqueU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u128, ReducerContext ctx, u128 n, int32_t data) +{ + ctx.db[unique_u128].insert(UniqueU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u128, ReducerContext ctx, u128 n, int32_t data) +{ + ctx.db[unique_u128].delete_by_value(UniqueU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u256, ReducerContext ctx, u256 n, int32_t data) +{ + ctx.db[unique_u256].insert(UniqueU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u256, ReducerContext ctx, u256 n, int32_t data) +{ + ctx.db[unique_u256].delete_by_value(UniqueU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i8, ReducerContext ctx, int8_t n, int32_t data) +{ + ctx.db[unique_i8].insert(UniqueI8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i8, ReducerContext ctx, int8_t n, int32_t data) +{ + ctx.db[unique_i8].delete_by_value(UniqueI8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i16, ReducerContext ctx, int16_t n, int32_t data) +{ + ctx.db[unique_i16].insert(UniqueI16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i16, ReducerContext ctx, int16_t n, int32_t data) +{ + ctx.db[unique_i16].delete_by_value(UniqueI16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i32, ReducerContext ctx, int32_t n, int32_t data) +{ + ctx.db[unique_i32].insert(UniqueI32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i32, ReducerContext ctx, int32_t n, int32_t data) +{ + ctx.db[unique_i32].delete_by_value(UniqueI32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i64, ReducerContext ctx, int64_t n, int32_t data) +{ + ctx.db[unique_i64].insert(UniqueI64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i64, ReducerContext ctx, int64_t n, int32_t data) +{ + ctx.db[unique_i64].delete_by_value(UniqueI64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i128, ReducerContext ctx, i128 n, int32_t data) +{ + ctx.db[unique_i128].insert(UniqueI128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i128, ReducerContext ctx, i128 n, int32_t data) +{ + ctx.db[unique_i128].delete_by_value(UniqueI128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i256, ReducerContext ctx, i256 n, int32_t data) +{ + ctx.db[unique_i256].insert(UniqueI256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i256, ReducerContext ctx, i256 n, int32_t data) +{ + ctx.db[unique_i256].delete_by_value(UniqueI256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_bool, ReducerContext ctx, bool b, int32_t data) +{ + ctx.db[unique_bool].insert(UniqueBool{b, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_bool, ReducerContext ctx, bool b, int32_t data) +{ + ctx.db[unique_bool].delete_by_value(UniqueBool{b, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_string, ReducerContext ctx, std::string s, int32_t data) +{ + ctx.db[unique_string].insert(UniqueString{s, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_string, ReducerContext ctx, std::string s, int32_t data) +{ + ctx.db[unique_string].delete_by_value(UniqueString{s, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_uuid, ReducerContext ctx, Uuid u, int32_t data) +{ + ctx.db[unique_uuid].insert(UniqueUuid{u, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_uuid, ReducerContext ctx, Uuid u, int32_t data) +{ + ctx.db[unique_uuid].delete_by_value(UniqueUuid{u, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_identity, ReducerContext ctx, Identity i, int32_t data) +{ + ctx.db[unique_identity].insert(UniqueIdentity{i, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_identity, ReducerContext ctx, Identity i, int32_t data) +{ + ctx.db[unique_identity].delete_by_value(UniqueIdentity{i, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) +{ + ctx.db[unique_connection_id].insert(UniqueConnectionId{a, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) +{ + ctx.db[unique_connection_id].delete_by_value(UniqueConnectionId{a, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u8, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u8].insert(UniqueOptionU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u8, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u8].delete_by_value(UniqueOptionU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u16, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u16].insert(UniqueOptionU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u16, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u16].delete_by_value(UniqueOptionU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u32, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u32].insert(UniqueOptionU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u32, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u32].delete_by_value(UniqueOptionU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u64, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u64].insert(UniqueOptionU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u64, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u64].delete_by_value(UniqueOptionU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u128, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u128].insert(UniqueOptionU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u128, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u128].delete_by_value(UniqueOptionU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u256, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u256].insert(UniqueOptionU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u256, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u256].delete_by_value(UniqueOptionU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_i8, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_string_i32].insert(ResultStringI32{r}); + ctx.db[unique_option_i8].insert(UniqueOptionI8{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_result_identity_string, ReducerContext ctx, Result r) +SPACETIMEDB_REDUCER(delete_all_unique_option_i8, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_identity_string].insert(ResultIdentityString{r}); + ctx.db[unique_option_i8].delete_by_value(UniqueOptionI8{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_result_simple_enum_i32, ReducerContext ctx, Result r) +SPACETIMEDB_REDUCER(insert_unique_option_i16, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_simple_enum_i32].insert(ResultSimpleEnumI32{r}); + ctx.db[unique_option_i16].insert(UniqueOptionI16{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_result_every_primitive_struct_string, ReducerContext ctx, Result r) +SPACETIMEDB_REDUCER(delete_all_unique_option_i16, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_every_primitive_struct_string].insert(ResultEveryPrimitiveStructString{r}); + ctx.db[unique_option_i16].delete_by_value(UniqueOptionI16{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_result_vec_i32_string, ReducerContext ctx, Result, std::string> r) +SPACETIMEDB_REDUCER(insert_unique_option_i32, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_vec_i32_string].insert(ResultVecI32String{r}); + ctx.db[unique_option_i32].insert(UniqueOptionI32{n, data}); return Ok(); } -// ============================================================================= -// UNIQUE CONSTRAINT TABLE REDUCERS -// ============================================================================= - -SPACETIMEDB_REDUCER(insert_unique_u8, ReducerContext ctx, uint8_t n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_i32, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u8].insert(UniqueU8{n, data}); + ctx.db[unique_option_i32].delete_by_value(UniqueOptionI32{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u16, ReducerContext ctx, uint16_t n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_i64, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u16].insert(UniqueU16{n, data}); + ctx.db[unique_option_i64].insert(UniqueOptionI64{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u32, ReducerContext ctx, uint32_t n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_i64, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u32].insert(UniqueU32{n, data}); + ctx.db[unique_option_i64].delete_by_value(UniqueOptionI64{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u64, ReducerContext ctx, uint64_t n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_i128, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u64].insert(UniqueU64{n, data}); + ctx.db[unique_option_i128].insert(UniqueOptionI128{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u128, ReducerContext ctx, u128 n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_i128, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u128].insert(UniqueU128{n, data}); + ctx.db[unique_option_i128].delete_by_value(UniqueOptionI128{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u256, ReducerContext ctx, u256 n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_i256, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u256].insert(UniqueU256{n, data}); + ctx.db[unique_option_i256].insert(UniqueOptionI256{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i8, ReducerContext ctx, int8_t n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_i256, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_i8].insert(UniqueI8{n, data}); + ctx.db[unique_option_i256].delete_by_value(UniqueOptionI256{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i16, ReducerContext ctx, int16_t n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_bool, ReducerContext ctx, std::optional b, int32_t data) { - ctx.db[unique_i16].insert(UniqueI16{n, data}); + ctx.db[unique_option_bool].insert(UniqueOptionBool{b, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i32, ReducerContext ctx, int32_t n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_bool, ReducerContext ctx, std::optional b, int32_t data) { - ctx.db[unique_i32].insert(UniqueI32{n, data}); + ctx.db[unique_option_bool].delete_by_value(UniqueOptionBool{b, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i64, ReducerContext ctx, int64_t n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_string, ReducerContext ctx, std::optional s, int32_t data) { - ctx.db[unique_i64].insert(UniqueI64{n, data}); + ctx.db[unique_option_string].insert(UniqueOptionString{s, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i128, ReducerContext ctx, i128 n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_string, ReducerContext ctx, std::optional s, int32_t data) { - ctx.db[unique_i128].insert(UniqueI128{n, data}); + ctx.db[unique_option_string].delete_by_value(UniqueOptionString{s, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i256, ReducerContext ctx, i256 n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_identity, ReducerContext ctx, std::optional i, int32_t data) { - ctx.db[unique_i256].insert(UniqueI256{n, data}); + ctx.db[unique_option_identity].insert(UniqueOptionIdentity{i, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_bool, ReducerContext ctx, bool b, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_identity, ReducerContext ctx, std::optional i, int32_t data) { - ctx.db[unique_bool].insert(UniqueBool{b, data}); + ctx.db[unique_option_identity].delete_by_value(UniqueOptionIdentity{i, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_string, ReducerContext ctx, std::string s, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_connection_id, ReducerContext ctx, std::optional a, int32_t data) { - ctx.db[unique_string].insert(UniqueString{s, data}); + ctx.db[unique_option_connection_id].insert(UniqueOptionConnectionId{a, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_uuid, ReducerContext ctx, Uuid u, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_connection_id, ReducerContext ctx, std::optional a, int32_t data) { - ctx.db[unique_uuid].insert(UniqueUuid{u, data}); + ctx.db[unique_option_connection_id].delete_by_value(UniqueOptionConnectionId{a, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_identity, ReducerContext ctx, Identity i, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_uuid, ReducerContext ctx, std::optional u, int32_t data) { - ctx.db[unique_identity].insert(UniqueIdentity{i, data}); + ctx.db[unique_option_uuid].insert(UniqueOptionUuid{u, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_uuid, ReducerContext ctx, std::optional u, int32_t data) { - ctx.db[unique_connection_id].insert(UniqueConnectionId{a, data}); + ctx.db[unique_option_uuid].delete_by_value(UniqueOptionUuid{u, data}); return Ok(); } @@ -1219,108 +1956,216 @@ SPACETIMEDB_REDUCER(insert_pk_u8, ReducerContext ctx, uint8_t n, int32_t data) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u8, ReducerContext ctx, uint8_t n, int32_t data) +{ + ctx.db[pk_u8].delete_by_value(PkU8{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u16, ReducerContext ctx, uint16_t n, int32_t data) { ctx.db[pk_u16].insert(PkU16{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u16, ReducerContext ctx, uint16_t n, int32_t data) +{ + ctx.db[pk_u16].delete_by_value(PkU16{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u32, ReducerContext ctx, uint32_t n, int32_t data) { ctx.db[pk_u32].insert(PkU32{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u32, ReducerContext ctx, uint32_t n, int32_t data) +{ + ctx.db[pk_u32].delete_by_value(PkU32{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u32_two, ReducerContext ctx, uint32_t n, int32_t data) { ctx.db[pk_u32_two].insert(PkU32Two{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u32_two, ReducerContext ctx, uint32_t n, int32_t data) +{ + ctx.db[pk_u32_two].delete_by_value(PkU32Two{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u64, ReducerContext ctx, uint64_t n, int32_t data) { ctx.db[pk_u64].insert(PkU64{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u64, ReducerContext ctx, uint64_t n, int32_t data) +{ + ctx.db[pk_u64].delete_by_value(PkU64{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u128, ReducerContext ctx, u128 n, int32_t data) { ctx.db[pk_u128].insert(PkU128{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u128, ReducerContext ctx, u128 n, int32_t data) +{ + ctx.db[pk_u128].delete_by_value(PkU128{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u256, ReducerContext ctx, u256 n, int32_t data) { ctx.db[pk_u256].insert(PkU256{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u256, ReducerContext ctx, u256 n, int32_t data) +{ + ctx.db[pk_u256].delete_by_value(PkU256{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i8, ReducerContext ctx, int8_t n, int32_t data) { ctx.db[pk_i8].insert(PkI8{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i8, ReducerContext ctx, int8_t n, int32_t data) +{ + ctx.db[pk_i8].delete_by_value(PkI8{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i16, ReducerContext ctx, int16_t n, int32_t data) { ctx.db[pk_i16].insert(PkI16{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i16, ReducerContext ctx, int16_t n, int32_t data) +{ + ctx.db[pk_i16].delete_by_value(PkI16{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i32, ReducerContext ctx, int32_t n, int32_t data) { ctx.db[pk_i32].insert(PkI32{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i32, ReducerContext ctx, int32_t n, int32_t data) +{ + ctx.db[pk_i32].delete_by_value(PkI32{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i64, ReducerContext ctx, int64_t n, int32_t data) { ctx.db[pk_i64].insert(PkI64{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i64, ReducerContext ctx, int64_t n, int32_t data) +{ + ctx.db[pk_i64].delete_by_value(PkI64{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i128, ReducerContext ctx, i128 n, int32_t data) { ctx.db[pk_i128].insert(PkI128{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i128, ReducerContext ctx, i128 n, int32_t data) +{ + ctx.db[pk_i128].delete_by_value(PkI128{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i256, ReducerContext ctx, i256 n, int32_t data) { ctx.db[pk_i256].insert(PkI256{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i256, ReducerContext ctx, i256 n, int32_t data) +{ + ctx.db[pk_i256].delete_by_value(PkI256{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_bool, ReducerContext ctx, bool b, int32_t data) { ctx.db[pk_bool].insert(PkBool{b, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_bool, ReducerContext ctx, bool b, int32_t data) +{ + ctx.db[pk_bool].delete_by_value(PkBool{b, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_string, ReducerContext ctx, std::string s, int32_t data) { ctx.db[pk_string].insert(PkString{s, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_string, ReducerContext ctx, std::string s, int32_t data) +{ + ctx.db[pk_string].delete_by_value(PkString{s, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_identity, ReducerContext ctx, Identity i, int32_t data) { ctx.db[pk_identity].insert(PkIdentity{i, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_identity, ReducerContext ctx, Identity i, int32_t data) +{ + ctx.db[pk_identity].delete_by_value(PkIdentity{i, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) { ctx.db[pk_connection_id].insert(PkConnectionId{a, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) +{ + ctx.db[pk_connection_id].delete_by_value(PkConnectionId{a, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_uuid, ReducerContext ctx, Uuid u, int32_t data) { ctx.db[pk_uuid].insert(PkUuid{u, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_uuid, ReducerContext ctx, Uuid u, int32_t data) +{ + ctx.db[pk_uuid].delete_by_value(PkUuid{u, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_simple_enum, ReducerContext ctx, SimpleEnum a, int32_t data) { ctx.db[pk_simple_enum].insert(PkSimpleEnum{a, data}); @@ -1580,6 +2425,108 @@ SPACETIMEDB_REDUCER(delete_unique_connection_id, ReducerContext ctx, ConnectionI return Ok(); } +SPACETIMEDB_REDUCER(delete_unique_option_u8, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u8_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u16, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u16_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u32, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u32_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u64, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u64_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u128, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u128_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u256, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u256_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i8, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i8_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i16, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i16_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i32, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i32_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i64, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i64_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i128, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i128_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i256, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i256_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_bool, ReducerContext ctx, std::optional b) +{ + ctx.db[unique_option_bool_b].delete_by_value(b); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_string, ReducerContext ctx, std::optional s) +{ + ctx.db[unique_option_string_s].delete_by_value(s); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_identity, ReducerContext ctx, std::optional i) +{ + ctx.db[unique_option_identity_i].delete_by_value(i); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_connection_id, ReducerContext ctx, std::optional a) +{ + ctx.db[unique_option_connection_id_a].delete_by_value(a); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_uuid, ReducerContext ctx, std::optional u) +{ + ctx.db[unique_option_uuid_u].delete_by_value(u); + return Ok(); +} + // ============================================================================= // UPDATE OPERATIONS - PRIMARY KEY // ============================================================================= @@ -1840,6 +2787,108 @@ SPACETIMEDB_REDUCER(update_unique_connection_id, ReducerContext ctx, ConnectionI return Ok(); } +SPACETIMEDB_REDUCER(update_unique_option_u8, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u8_n].update(UniqueOptionU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u16, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u16_n].update(UniqueOptionU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u32, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u32_n].update(UniqueOptionU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u64, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u64_n].update(UniqueOptionU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u128, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u128_n].update(UniqueOptionU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u256, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u256_n].update(UniqueOptionU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i8, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i8_n].update(UniqueOptionI8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i16, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i16_n].update(UniqueOptionI16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i32, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i32_n].update(UniqueOptionI32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i64, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i64_n].update(UniqueOptionI64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i128, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i128_n].update(UniqueOptionI128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i256, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i256_n].update(UniqueOptionI256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_bool, ReducerContext ctx, std::optional b, int32_t data) +{ + ctx.db[unique_option_bool_b].update(UniqueOptionBool{b, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_string, ReducerContext ctx, std::optional s, int32_t data) +{ + ctx.db[unique_option_string_s].update(UniqueOptionString{s, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_identity, ReducerContext ctx, std::optional i, int32_t data) +{ + ctx.db[unique_option_identity_i].update(UniqueOptionIdentity{i, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_connection_id, ReducerContext ctx, std::optional a, int32_t data) +{ + ctx.db[unique_option_connection_id_a].update(UniqueOptionConnectionId{a, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_uuid, ReducerContext ctx, std::optional u, int32_t data) +{ + ctx.db[unique_option_uuid_u].update(UniqueOptionUuid{u, data}); + return Ok(); +} + // ============================================================================= // COMPREHENSIVE TABLE REDUCERS // ============================================================================= diff --git a/modules/sdk-test-cs/Lib.cs b/modules/sdk-test-cs/Lib.cs index ade952a1412..c83f19560e5 100644 --- a/modules/sdk-test-cs/Lib.cs +++ b/modules/sdk-test-cs/Lib.cs @@ -116,6 +116,12 @@ public static void insert_one_u8(ReducerContext ctx, byte n) ctx.Db.one_u8.Insert(new OneU8 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u8(ReducerContext ctx, byte n) + { + ctx.Db.one_u8.Delete(new OneU8 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u16", Public = true)] public partial struct OneU16 { @@ -128,6 +134,12 @@ public static void insert_one_u16(ReducerContext ctx, ushort n) ctx.Db.one_u16.Insert(new OneU16 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u16(ReducerContext ctx, ushort n) + { + ctx.Db.one_u16.Delete(new OneU16 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u32", Public = true)] public partial struct OneU32 { @@ -140,6 +152,12 @@ public static void insert_one_u32(ReducerContext ctx, uint n) ctx.Db.one_u32.Insert(new OneU32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u32(ReducerContext ctx, uint n) + { + ctx.Db.one_u32.Delete(new OneU32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u64", Public = true)] public partial struct OneU64 { @@ -152,6 +170,12 @@ public static void insert_one_u64(ReducerContext ctx, ulong n) ctx.Db.one_u64.Insert(new OneU64 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u64(ReducerContext ctx, ulong n) + { + ctx.Db.one_u64.Delete(new OneU64 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u128", Public = true)] public partial struct OneU128 { @@ -164,6 +188,12 @@ public static void insert_one_u128(ReducerContext ctx, U128 n) ctx.Db.one_u128.Insert(new OneU128 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u128(ReducerContext ctx, U128 n) + { + ctx.Db.one_u128.Delete(new OneU128 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u256", Public = true)] public partial struct OneU256 { @@ -176,6 +206,12 @@ public static void insert_one_u256(ReducerContext ctx, U256 n) ctx.Db.one_u256.Insert(new OneU256 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u256(ReducerContext ctx, U256 n) + { + ctx.Db.one_u256.Delete(new OneU256 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i8", Public = true)] public partial struct OneI8 { @@ -188,6 +224,12 @@ public static void insert_one_i8(ReducerContext ctx, sbyte n) ctx.Db.one_i8.Insert(new OneI8 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i8(ReducerContext ctx, sbyte n) + { + ctx.Db.one_i8.Delete(new OneI8 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i16", Public = true)] public partial struct OneI16 { @@ -200,6 +242,12 @@ public static void insert_one_i16(ReducerContext ctx, short n) ctx.Db.one_i16.Insert(new OneI16 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i16(ReducerContext ctx, short n) + { + ctx.Db.one_i16.Delete(new OneI16 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i32", Public = true)] public partial struct OneI32 { @@ -212,6 +260,12 @@ public static void insert_one_i32(ReducerContext ctx, int n) ctx.Db.one_i32.Insert(new OneI32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i32(ReducerContext ctx, int n) + { + ctx.Db.one_i32.Delete(new OneI32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i64", Public = true)] public partial struct OneI64 { @@ -224,6 +278,12 @@ public static void insert_one_i64(ReducerContext ctx, long n) ctx.Db.one_i64.Insert(new OneI64 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i64(ReducerContext ctx, long n) + { + ctx.Db.one_i64.Delete(new OneI64 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i128", Public = true)] public partial struct OneI128 { @@ -236,6 +296,12 @@ public static void insert_one_i128(ReducerContext ctx, I128 n) ctx.Db.one_i128.Insert(new OneI128 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i128(ReducerContext ctx, I128 n) + { + ctx.Db.one_i128.Delete(new OneI128 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i256", Public = true)] public partial struct OneI256 { @@ -248,6 +314,12 @@ public static void insert_one_i256(ReducerContext ctx, I256 n) ctx.Db.one_i256.Insert(new OneI256 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i256(ReducerContext ctx, I256 n) + { + ctx.Db.one_i256.Delete(new OneI256 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_bool", Public = true)] public partial struct OneBool { @@ -260,6 +332,12 @@ public static void insert_one_bool(ReducerContext ctx, bool b) ctx.Db.one_bool.Insert(new OneBool { b = b }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_bool(ReducerContext ctx, bool b) + { + ctx.Db.one_bool.Delete(new OneBool { b = b }); + } + [SpacetimeDB.Table(Accessor = "one_f32", Public = true)] public partial struct OneF32 { @@ -272,6 +350,12 @@ public static void insert_one_f32(ReducerContext ctx, float f) ctx.Db.one_f32.Insert(new OneF32 { f = f }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_f32(ReducerContext ctx, float f) + { + ctx.Db.one_f32.Delete(new OneF32 { f = f }); + } + [SpacetimeDB.Table(Accessor = "one_f64", Public = true)] public partial struct OneF64 { @@ -284,6 +368,12 @@ public static void insert_one_f64(ReducerContext ctx, double f) ctx.Db.one_f64.Insert(new OneF64 { f = f }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_f64(ReducerContext ctx, double f) + { + ctx.Db.one_f64.Delete(new OneF64 { f = f }); + } + [SpacetimeDB.Table(Accessor = "one_string", Public = true)] public partial struct OneString { @@ -296,6 +386,12 @@ public static void insert_one_string(ReducerContext ctx, string s) ctx.Db.one_string.Insert(new OneString { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_string(ReducerContext ctx, string s) + { + ctx.Db.one_string.Delete(new OneString { s = s }); + } + [SpacetimeDB.Table(Accessor = "one_identity", Public = true)] public partial struct OneIdentity { @@ -308,6 +404,12 @@ public static void insert_one_identity(ReducerContext ctx, Identity i) ctx.Db.one_identity.Insert(new OneIdentity { i = i }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_identity(ReducerContext ctx, Identity i) + { + ctx.Db.one_identity.Delete(new OneIdentity { i = i }); + } + [SpacetimeDB.Table(Accessor = "one_connection_id", Public = true)] public partial struct OneConnectionId { @@ -332,6 +434,12 @@ public static void insert_one_uuid(ReducerContext ctx, Uuid u) ctx.Db.one_uuid.Insert(new OneUuid { u = u }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_uuid(ReducerContext ctx, Uuid u) + { + ctx.Db.one_uuid.Delete(new OneUuid { u = u }); + } + [SpacetimeDB.Table(Accessor = "one_timestamp", Public = true)] public partial struct OneTimestamp { @@ -344,6 +452,12 @@ public static void insert_one_timestamp(ReducerContext ctx, Timestamp t) ctx.Db.one_timestamp.Insert(new OneTimestamp { t = t }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_timestamp(ReducerContext ctx, Timestamp t) + { + ctx.Db.one_timestamp.Delete(new OneTimestamp { t = t }); + } + [SpacetimeDB.Table(Accessor = "one_simple_enum", Public = true)] public partial struct OneSimpleEnum { @@ -356,6 +470,12 @@ public static void insert_one_simple_enum(ReducerContext ctx, SimpleEnum e) ctx.Db.one_simple_enum.Insert(new OneSimpleEnum { e = e }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_simple_enum(ReducerContext ctx, SimpleEnum e) + { + ctx.Db.one_simple_enum.Delete(new OneSimpleEnum { e = e }); + } + [SpacetimeDB.Table(Accessor = "one_enum_with_payload", Public = true)] public partial struct OneEnumWithPayload { @@ -368,6 +488,12 @@ public static void insert_one_enum_with_payload(ReducerContext ctx, EnumWithPayl ctx.Db.one_enum_with_payload.Insert(new OneEnumWithPayload { e = e }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_enum_with_payload(ReducerContext ctx, EnumWithPayload e) + { + ctx.Db.one_enum_with_payload.Delete(new OneEnumWithPayload { e = e }); + } + [SpacetimeDB.Table(Accessor = "one_unit_struct", Public = true)] public partial struct OneUnitStruct { @@ -380,6 +506,12 @@ public static void insert_one_unit_struct(ReducerContext ctx, UnitStruct s) ctx.Db.one_unit_struct.Insert(new OneUnitStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_unit_struct(ReducerContext ctx, UnitStruct s) + { + ctx.Db.one_unit_struct.Delete(new OneUnitStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "one_byte_struct", Public = true)] public partial struct OneByteStruct { @@ -392,6 +524,12 @@ public static void insert_one_byte_struct(ReducerContext ctx, ByteStruct s) ctx.Db.one_byte_struct.Insert(new OneByteStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_byte_struct(ReducerContext ctx, ByteStruct s) + { + ctx.Db.one_byte_struct.Delete(new OneByteStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "one_every_primitive_struct", Public = true)] public partial struct OneEveryPrimitiveStruct { @@ -404,6 +542,12 @@ public static void insert_one_every_primitive_struct(ReducerContext ctx, EveryPr ctx.Db.one_every_primitive_struct.Insert(new OneEveryPrimitiveStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_every_primitive_struct(ReducerContext ctx, EveryPrimitiveStruct s) + { + ctx.Db.one_every_primitive_struct.Delete(new OneEveryPrimitiveStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "one_every_vec_struct", Public = true)] public partial struct OneEveryVecStruct { @@ -416,6 +560,12 @@ public static void insert_one_every_vec_struct(ReducerContext ctx, EveryVecStruc ctx.Db.one_every_vec_struct.Insert(new OneEveryVecStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_every_vec_struct(ReducerContext ctx, EveryVecStruct s) + { + ctx.Db.one_every_vec_struct.Delete(new OneEveryVecStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_u8", Public = true)] public partial struct VecU8 { @@ -428,6 +578,12 @@ public static void insert_vec_u8(ReducerContext ctx, List n) ctx.Db.vec_u8.Insert(new VecU8 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u8(ReducerContext ctx, List n) + { + ctx.Db.vec_u8.Delete(new VecU8 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u16", Public = true)] public partial struct VecU16 { @@ -440,6 +596,12 @@ public static void insert_vec_u16(ReducerContext ctx, List n) ctx.Db.vec_u16.Insert(new VecU16 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u16(ReducerContext ctx, List n) + { + ctx.Db.vec_u16.Delete(new VecU16 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u32", Public = true)] public partial struct VecU32 { @@ -452,6 +614,12 @@ public static void insert_vec_u32(ReducerContext ctx, List n) ctx.Db.vec_u32.Insert(new VecU32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u32(ReducerContext ctx, List n) + { + ctx.Db.vec_u32.Delete(new VecU32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u64", Public = true)] public partial struct VecU64 { @@ -464,6 +632,12 @@ public static void insert_vec_u64(ReducerContext ctx, List n) ctx.Db.vec_u64.Insert(new VecU64 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u64(ReducerContext ctx, List n) + { + ctx.Db.vec_u64.Delete(new VecU64 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u128", Public = true)] public partial struct VecU128 { @@ -476,6 +650,12 @@ public static void insert_vec_u128(ReducerContext ctx, List n) ctx.Db.vec_u128.Insert(new VecU128 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u128(ReducerContext ctx, List n) + { + ctx.Db.vec_u128.Delete(new VecU128 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u256", Public = true)] public partial struct VecU256 { @@ -488,6 +668,12 @@ public static void insert_vec_u256(ReducerContext ctx, List n) ctx.Db.vec_u256.Insert(new VecU256 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u256(ReducerContext ctx, List n) + { + ctx.Db.vec_u256.Delete(new VecU256 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i8", Public = true)] public partial struct VecI8 { @@ -500,6 +686,12 @@ public static void insert_vec_i8(ReducerContext ctx, List n) ctx.Db.vec_i8.Insert(new VecI8 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i8(ReducerContext ctx, List n) + { + ctx.Db.vec_i8.Delete(new VecI8 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i16", Public = true)] public partial struct VecI16 { @@ -512,6 +704,12 @@ public static void insert_vec_i16(ReducerContext ctx, List n) ctx.Db.vec_i16.Insert(new VecI16 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i16(ReducerContext ctx, List n) + { + ctx.Db.vec_i16.Delete(new VecI16 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i32", Public = true)] public partial struct VecI32 { @@ -524,6 +722,12 @@ public static void insert_vec_i32(ReducerContext ctx, List n) ctx.Db.vec_i32.Insert(new VecI32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i32(ReducerContext ctx, List n) + { + ctx.Db.vec_i32.Delete(new VecI32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i64", Public = true)] public partial struct VecI64 { @@ -536,6 +740,12 @@ public static void insert_vec_i64(ReducerContext ctx, List n) ctx.Db.vec_i64.Insert(new VecI64 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i64(ReducerContext ctx, List n) + { + ctx.Db.vec_i64.Delete(new VecI64 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i128", Public = true)] public partial struct VecI128 { @@ -548,6 +758,12 @@ public static void insert_vec_i128(ReducerContext ctx, List n) ctx.Db.vec_i128.Insert(new VecI128 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i128(ReducerContext ctx, List n) + { + ctx.Db.vec_i128.Delete(new VecI128 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i256", Public = true)] public partial struct VecI256 { @@ -560,6 +776,12 @@ public static void insert_vec_i256(ReducerContext ctx, List n) ctx.Db.vec_i256.Insert(new VecI256 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i256(ReducerContext ctx, List n) + { + ctx.Db.vec_i256.Delete(new VecI256 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_bool", Public = true)] public partial struct VecBool { @@ -572,6 +794,12 @@ public static void insert_vec_bool(ReducerContext ctx, List b) ctx.Db.vec_bool.Insert(new VecBool { b = b }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_bool(ReducerContext ctx, List b) + { + ctx.Db.vec_bool.Delete(new VecBool { b = b }); + } + [SpacetimeDB.Table(Accessor = "vec_f32", Public = true)] public partial struct VecF32 { @@ -584,6 +812,12 @@ public static void insert_vec_f32(ReducerContext ctx, List f) ctx.Db.vec_f32.Insert(new VecF32 { f = f }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_f32(ReducerContext ctx, List f) + { + ctx.Db.vec_f32.Delete(new VecF32 { f = f }); + } + [SpacetimeDB.Table(Accessor = "vec_f64", Public = true)] public partial struct VecF64 { @@ -596,6 +830,12 @@ public static void insert_vec_f64(ReducerContext ctx, List f) ctx.Db.vec_f64.Insert(new VecF64 { f = f }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_f64(ReducerContext ctx, List f) + { + ctx.Db.vec_f64.Delete(new VecF64 { f = f }); + } + [SpacetimeDB.Table(Accessor = "vec_string", Public = true)] public partial struct VecString { @@ -608,6 +848,12 @@ public static void insert_vec_string(ReducerContext ctx, List s) ctx.Db.vec_string.Insert(new VecString { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_string(ReducerContext ctx, List s) + { + ctx.Db.vec_string.Delete(new VecString { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_identity", Public = true)] public partial struct VecIdentity { @@ -620,6 +866,12 @@ public static void insert_vec_identity(ReducerContext ctx, List i) ctx.Db.vec_identity.Insert(new VecIdentity { i = i }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_identity(ReducerContext ctx, List i) + { + ctx.Db.vec_identity.Delete(new VecIdentity { i = i }); + } + [SpacetimeDB.Table(Accessor = "vec_connection_id", Public = true)] public partial struct VecConnectionId { @@ -644,6 +896,12 @@ public static void insert_vec_uuid(ReducerContext ctx, List u) ctx.Db.vec_uuid.Insert(new VecUuid { u = u }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_uuid(ReducerContext ctx, List u) + { + ctx.Db.vec_uuid.Delete(new VecUuid { u = u }); + } + [SpacetimeDB.Table(Accessor = "vec_timestamp", Public = true)] public partial struct VecTimestamp { @@ -656,6 +914,12 @@ public static void insert_vec_timestamp(ReducerContext ctx, List t) ctx.Db.vec_timestamp.Insert(new VecTimestamp { t = t }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_timestamp(ReducerContext ctx, List t) + { + ctx.Db.vec_timestamp.Delete(new VecTimestamp { t = t }); + } + [SpacetimeDB.Table(Accessor = "vec_simple_enum", Public = true)] public partial struct VecSimpleEnum { @@ -668,6 +932,12 @@ public static void insert_vec_simple_enum(ReducerContext ctx, List e ctx.Db.vec_simple_enum.Insert(new VecSimpleEnum { e = e }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_simple_enum(ReducerContext ctx, List e) + { + ctx.Db.vec_simple_enum.Delete(new VecSimpleEnum { e = e }); + } + [SpacetimeDB.Table(Accessor = "vec_enum_with_payload", Public = true)] public partial struct VecEnumWithPayload { @@ -680,6 +950,12 @@ public static void insert_vec_enum_with_payload(ReducerContext ctx, List e) + { + ctx.Db.vec_enum_with_payload.Delete(new VecEnumWithPayload { e = e }); + } + [SpacetimeDB.Table(Accessor = "vec_unit_struct", Public = true)] public partial struct VecUnitStruct { @@ -692,6 +968,12 @@ public static void insert_vec_unit_struct(ReducerContext ctx, List s ctx.Db.vec_unit_struct.Insert(new VecUnitStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_unit_struct(ReducerContext ctx, List s) + { + ctx.Db.vec_unit_struct.Delete(new VecUnitStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_byte_struct", Public = true)] public partial struct VecByteStruct { @@ -704,6 +986,12 @@ public static void insert_vec_byte_struct(ReducerContext ctx, List s ctx.Db.vec_byte_struct.Insert(new VecByteStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_byte_struct(ReducerContext ctx, List s) + { + ctx.Db.vec_byte_struct.Delete(new VecByteStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_every_primitive_struct", Public = true)] public partial struct VecEveryPrimitiveStruct { @@ -719,6 +1007,15 @@ List s ctx.Db.vec_every_primitive_struct.Insert(new VecEveryPrimitiveStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_every_primitive_struct( + ReducerContext ctx, + List s + ) + { + ctx.Db.vec_every_primitive_struct.Delete(new VecEveryPrimitiveStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_every_vec_struct", Public = true)] public partial struct VecEveryVecStruct { @@ -731,6 +1028,12 @@ public static void insert_vec_every_vec_struct(ReducerContext ctx, List s) + { + ctx.Db.vec_every_vec_struct.Delete(new VecEveryVecStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "option_i32", Public = true)] public partial struct OptionI32 { @@ -743,6 +1046,12 @@ public static void insert_option_i32(ReducerContext ctx, int? n) ctx.Db.option_i32.Insert(new OptionI32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_i32(ReducerContext ctx, int? n) + { + ctx.Db.option_i32.Delete(new OptionI32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "option_string", Public = true)] public partial struct OptionString { @@ -755,6 +1064,12 @@ public static void insert_option_string(ReducerContext ctx, string? s) ctx.Db.option_string.Insert(new OptionString { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_string(ReducerContext ctx, string? s) + { + ctx.Db.option_string.Delete(new OptionString { s = s }); + } + [SpacetimeDB.Table(Accessor = "option_identity", Public = true)] public partial struct OptionIdentity { @@ -767,6 +1082,12 @@ public static void insert_option_identity(ReducerContext ctx, Identity? i) ctx.Db.option_identity.Insert(new OptionIdentity { i = i }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_identity(ReducerContext ctx, Identity? i) + { + ctx.Db.option_identity.Delete(new OptionIdentity { i = i }); + } + [SpacetimeDB.Table(Accessor = "option_uuid", Public = true)] public partial struct OptionUuid { @@ -779,6 +1100,12 @@ public static void insert_option_uuid(ReducerContext ctx, Uuid? u) ctx.Db.option_uuid.Insert(new OptionUuid { u = u }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_uuid(ReducerContext ctx, Uuid? u) + { + ctx.Db.option_uuid.Delete(new OptionUuid { u = u }); + } + [SpacetimeDB.Table(Accessor = "option_simple_enum", Public = true)] public partial struct OptionSimpleEnum { @@ -791,6 +1118,12 @@ public static void insert_option_simple_enum(ReducerContext ctx, SimpleEnum? e) ctx.Db.option_simple_enum.Insert(new OptionSimpleEnum { e = e }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_simple_enum(ReducerContext ctx, SimpleEnum? e) + { + ctx.Db.option_simple_enum.Delete(new OptionSimpleEnum { e = e }); + } + [SpacetimeDB.Table(Accessor = "option_every_primitive_struct", Public = true)] public partial struct OptionEveryPrimitiveStruct { @@ -806,6 +1139,15 @@ public static void insert_option_every_primitive_struct( ctx.Db.option_every_primitive_struct.Insert(new OptionEveryPrimitiveStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_every_primitive_struct( + ReducerContext ctx, + EveryPrimitiveStruct? s + ) + { + ctx.Db.option_every_primitive_struct.Delete(new OptionEveryPrimitiveStruct { s = s }); + } + [Table(Accessor = "result_i32_string", Public = true)] public partial struct ResultI32String { @@ -898,6 +1240,12 @@ public static void insert_option_vec_option_i32(ReducerContext ctx, List? ctx.Db.option_vec_option_i32.Insert(new OptionVecOptionI32 { v = v }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_vec_option_i32(ReducerContext ctx, List? v) + { + ctx.Db.option_vec_option_i32.Delete(new OptionVecOptionI32 { v = v }); + } + [SpacetimeDB.Table(Accessor = "unique_u8", Public = true)] public partial struct UniqueU8 { @@ -912,6 +1260,12 @@ public static void insert_unique_u8(ReducerContext ctx, byte n, int data) ctx.Db.unique_u8.Insert(new UniqueU8 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u8(ReducerContext ctx, byte n, int data) + { + ctx.Db.unique_u8.Delete(new UniqueU8 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_u8(ReducerContext ctx, byte n, int data) { @@ -939,6 +1293,12 @@ public static void insert_unique_u16(ReducerContext ctx, ushort n, int data) ctx.Db.unique_u16.Insert(new UniqueU16 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u16(ReducerContext ctx, ushort n, int data) + { + ctx.Db.unique_u16.Delete(new UniqueU16 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_u16(ReducerContext ctx, ushort n, int data) { @@ -966,6 +1326,12 @@ public static void insert_unique_u32(ReducerContext ctx, uint n, int data) ctx.Db.unique_u32.Insert(new UniqueU32 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u32(ReducerContext ctx, uint n, int data) + { + ctx.Db.unique_u32.Delete(new UniqueU32 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void insert_unique_u32_update_pk_u32( ReducerContext ctx, @@ -1005,6 +1371,12 @@ public static void insert_unique_u64(ReducerContext ctx, ulong n, int data) ctx.Db.unique_u64.Insert(new UniqueU64 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u64(ReducerContext ctx, ulong n, int data) + { + ctx.Db.unique_u64.Delete(new UniqueU64 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_u64(ReducerContext ctx, ulong n, int data) { @@ -1032,6 +1404,12 @@ public static void insert_unique_u128(ReducerContext ctx, U128 n, int data) ctx.Db.unique_u128.Insert(new UniqueU128 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u128(ReducerContext ctx, U128 n, int data) + { + ctx.Db.unique_u128.Delete(new UniqueU128 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_u128(ReducerContext ctx, U128 n, int data) { @@ -1060,9 +1438,15 @@ public static void insert_unique_u256(ReducerContext ctx, U256 n, int data) } [SpacetimeDB.Reducer] - public static void update_unique_u256(ReducerContext ctx, U256 n, int data) + public static void delete_all_unique_u256(ReducerContext ctx, U256 n, int data) { - ctx.Db.unique_u256.n.Delete(n); + ctx.Db.unique_u256.Delete(new UniqueU256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_u256(ReducerContext ctx, U256 n, int data) + { + ctx.Db.unique_u256.n.Delete(n); ctx.Db.unique_u256.Insert(new UniqueU256 { n = n, data = data }); } @@ -1086,6 +1470,12 @@ public static void insert_unique_i8(ReducerContext ctx, sbyte n, int data) ctx.Db.unique_i8.Insert(new UniqueI8 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i8(ReducerContext ctx, sbyte n, int data) + { + ctx.Db.unique_i8.Delete(new UniqueI8 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i8(ReducerContext ctx, sbyte n, int data) { @@ -1113,6 +1503,12 @@ public static void insert_unique_i16(ReducerContext ctx, short n, int data) ctx.Db.unique_i16.Insert(new UniqueI16 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i16(ReducerContext ctx, short n, int data) + { + ctx.Db.unique_i16.Delete(new UniqueI16 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i16(ReducerContext ctx, short n, int data) { @@ -1140,6 +1536,12 @@ public static void insert_unique_i32(ReducerContext ctx, int n, int data) ctx.Db.unique_i32.Insert(new UniqueI32 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i32(ReducerContext ctx, int n, int data) + { + ctx.Db.unique_i32.Delete(new UniqueI32 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i32(ReducerContext ctx, int n, int data) { @@ -1167,6 +1569,12 @@ public static void insert_unique_i64(ReducerContext ctx, long n, int data) ctx.Db.unique_i64.Insert(new UniqueI64 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i64(ReducerContext ctx, long n, int data) + { + ctx.Db.unique_i64.Delete(new UniqueI64 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i64(ReducerContext ctx, long n, int data) { @@ -1194,6 +1602,12 @@ public static void insert_unique_i128(ReducerContext ctx, I128 n, int data) ctx.Db.unique_i128.Insert(new UniqueI128 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i128(ReducerContext ctx, I128 n, int data) + { + ctx.Db.unique_i128.Delete(new UniqueI128 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i128(ReducerContext ctx, I128 n, int data) { @@ -1221,6 +1635,12 @@ public static void insert_unique_i256(ReducerContext ctx, I256 n, int data) ctx.Db.unique_i256.Insert(new UniqueI256 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i256(ReducerContext ctx, I256 n, int data) + { + ctx.Db.unique_i256.Delete(new UniqueI256 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i256(ReducerContext ctx, I256 n, int data) { @@ -1248,6 +1668,12 @@ public static void insert_unique_bool(ReducerContext ctx, bool b, int data) ctx.Db.unique_bool.Insert(new UniqueBool { b = b, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_bool(ReducerContext ctx, bool b, int data) + { + ctx.Db.unique_bool.Delete(new UniqueBool { b = b, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_bool(ReducerContext ctx, bool b, int data) { @@ -1275,6 +1701,12 @@ public static void insert_unique_string(ReducerContext ctx, string s, int data) ctx.Db.unique_string.Insert(new UniqueString { s = s, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_string(ReducerContext ctx, string s, int data) + { + ctx.Db.unique_string.Delete(new UniqueString { s = s, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_string(ReducerContext ctx, string s, int data) { @@ -1302,6 +1734,12 @@ public static void insert_unique_identity(ReducerContext ctx, Identity i, int da ctx.Db.unique_identity.Insert(new UniqueIdentity { i = i, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_identity(ReducerContext ctx, Identity i, int data) + { + ctx.Db.unique_identity.Delete(new UniqueIdentity { i = i, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_identity(ReducerContext ctx, Identity i, int data) { @@ -1329,6 +1767,12 @@ public static void insert_unique_connection_id(ReducerContext ctx, ConnectionId ctx.Db.unique_connection_id.Insert(new UniqueConnectionId { a = a, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_connection_id(ReducerContext ctx, ConnectionId a, int data) + { + ctx.Db.unique_connection_id.Delete(new UniqueConnectionId { a = a, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_connection_id(ReducerContext ctx, ConnectionId a, int data) { @@ -1356,6 +1800,12 @@ public static void insert_unique_uuid(ReducerContext ctx, Uuid u, int data) ctx.Db.unique_uuid.Insert(new UniqueUuid { u = u, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_uuid(ReducerContext ctx, Uuid u, int data) + { + ctx.Db.unique_uuid.Delete(new UniqueUuid { u = u, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_uuid(ReducerContext ctx, Uuid u, int data) { @@ -1369,6 +1819,567 @@ public static void delete_unique_uuid(ReducerContext ctx, Uuid u) ctx.Db.unique_uuid.u.Delete(u); } + [SpacetimeDB.Table(Accessor = "unique_option_u8", Public = true)] + public partial struct UniqueOptionU8 + { + [SpacetimeDB.Unique] + public byte? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u8(ReducerContext ctx, byte? n, int data) + { + ctx.Db.unique_option_u8.Insert(new UniqueOptionU8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u8(ReducerContext ctx, byte? n, int data) + { + ctx.Db.unique_option_u8.Delete(new UniqueOptionU8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u8(ReducerContext ctx, byte? n, int data) + { + ctx.Db.unique_option_u8.n.Delete(n); + ctx.Db.unique_option_u8.Insert(new UniqueOptionU8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u8(ReducerContext ctx, byte? n) + { + ctx.Db.unique_option_u8.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u16", Public = true)] + public partial struct UniqueOptionU16 + { + [SpacetimeDB.Unique] + public ushort? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u16(ReducerContext ctx, ushort? n, int data) + { + ctx.Db.unique_option_u16.Insert(new UniqueOptionU16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u16(ReducerContext ctx, ushort? n, int data) + { + ctx.Db.unique_option_u16.Delete(new UniqueOptionU16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u16(ReducerContext ctx, ushort? n, int data) + { + ctx.Db.unique_option_u16.n.Delete(n); + ctx.Db.unique_option_u16.Insert(new UniqueOptionU16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u16(ReducerContext ctx, ushort? n) + { + ctx.Db.unique_option_u16.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u32", Public = true)] + public partial struct UniqueOptionU32 + { + [SpacetimeDB.Unique] + public uint? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u32(ReducerContext ctx, uint? n, int data) + { + ctx.Db.unique_option_u32.Insert(new UniqueOptionU32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u32(ReducerContext ctx, uint? n, int data) + { + ctx.Db.unique_option_u32.Delete(new UniqueOptionU32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u32(ReducerContext ctx, uint? n, int data) + { + ctx.Db.unique_option_u32.n.Delete(n); + ctx.Db.unique_option_u32.Insert(new UniqueOptionU32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u32(ReducerContext ctx, uint? n) + { + ctx.Db.unique_option_u32.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u64", Public = true)] + public partial struct UniqueOptionU64 + { + [SpacetimeDB.Unique] + public ulong? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u64(ReducerContext ctx, ulong? n, int data) + { + ctx.Db.unique_option_u64.Insert(new UniqueOptionU64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u64(ReducerContext ctx, ulong? n, int data) + { + ctx.Db.unique_option_u64.Delete(new UniqueOptionU64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u64(ReducerContext ctx, ulong? n, int data) + { + ctx.Db.unique_option_u64.n.Delete(n); + ctx.Db.unique_option_u64.Insert(new UniqueOptionU64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u64(ReducerContext ctx, ulong? n) + { + ctx.Db.unique_option_u64.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u128", Public = true)] + public partial struct UniqueOptionU128 + { + [SpacetimeDB.Unique] + public U128? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u128(ReducerContext ctx, U128? n, int data) + { + ctx.Db.unique_option_u128.Insert(new UniqueOptionU128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u128(ReducerContext ctx, U128? n, int data) + { + ctx.Db.unique_option_u128.Delete(new UniqueOptionU128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u128(ReducerContext ctx, U128? n, int data) + { + ctx.Db.unique_option_u128.n.Delete(n); + ctx.Db.unique_option_u128.Insert(new UniqueOptionU128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u128(ReducerContext ctx, U128? n) + { + ctx.Db.unique_option_u128.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u256", Public = true)] + public partial struct UniqueOptionU256 + { + [SpacetimeDB.Unique] + public U256? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u256(ReducerContext ctx, U256? n, int data) + { + ctx.Db.unique_option_u256.Insert(new UniqueOptionU256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u256(ReducerContext ctx, U256? n, int data) + { + ctx.Db.unique_option_u256.Delete(new UniqueOptionU256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u256(ReducerContext ctx, U256? n, int data) + { + ctx.Db.unique_option_u256.n.Delete(n); + ctx.Db.unique_option_u256.Insert(new UniqueOptionU256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u256(ReducerContext ctx, U256? n) + { + ctx.Db.unique_option_u256.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i8", Public = true)] + public partial struct UniqueOptionI8 + { + [SpacetimeDB.Unique] + public sbyte? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i8(ReducerContext ctx, sbyte? n, int data) + { + ctx.Db.unique_option_i8.Insert(new UniqueOptionI8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i8(ReducerContext ctx, sbyte? n, int data) + { + ctx.Db.unique_option_i8.Delete(new UniqueOptionI8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i8(ReducerContext ctx, sbyte? n, int data) + { + ctx.Db.unique_option_i8.n.Delete(n); + ctx.Db.unique_option_i8.Insert(new UniqueOptionI8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i8(ReducerContext ctx, sbyte? n) + { + ctx.Db.unique_option_i8.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i16", Public = true)] + public partial struct UniqueOptionI16 + { + [SpacetimeDB.Unique] + public short? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i16(ReducerContext ctx, short? n, int data) + { + ctx.Db.unique_option_i16.Insert(new UniqueOptionI16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i16(ReducerContext ctx, short? n, int data) + { + ctx.Db.unique_option_i16.Delete(new UniqueOptionI16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i16(ReducerContext ctx, short? n, int data) + { + ctx.Db.unique_option_i16.n.Delete(n); + ctx.Db.unique_option_i16.Insert(new UniqueOptionI16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i16(ReducerContext ctx, short? n) + { + ctx.Db.unique_option_i16.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i32", Public = true)] + public partial struct UniqueOptionI32 + { + [SpacetimeDB.Unique] + public int? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i32(ReducerContext ctx, int? n, int data) + { + ctx.Db.unique_option_i32.Insert(new UniqueOptionI32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i32(ReducerContext ctx, int? n, int data) + { + ctx.Db.unique_option_i32.Delete(new UniqueOptionI32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i32(ReducerContext ctx, int? n, int data) + { + ctx.Db.unique_option_i32.n.Delete(n); + ctx.Db.unique_option_i32.Insert(new UniqueOptionI32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i32(ReducerContext ctx, int? n) + { + ctx.Db.unique_option_i32.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i64", Public = true)] + public partial struct UniqueOptionI64 + { + [SpacetimeDB.Unique] + public long? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i64(ReducerContext ctx, long? n, int data) + { + ctx.Db.unique_option_i64.Insert(new UniqueOptionI64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i64(ReducerContext ctx, long? n, int data) + { + ctx.Db.unique_option_i64.Delete(new UniqueOptionI64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i64(ReducerContext ctx, long? n, int data) + { + ctx.Db.unique_option_i64.n.Delete(n); + ctx.Db.unique_option_i64.Insert(new UniqueOptionI64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i64(ReducerContext ctx, long? n) + { + ctx.Db.unique_option_i64.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i128", Public = true)] + public partial struct UniqueOptionI128 + { + [SpacetimeDB.Unique] + public I128? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i128(ReducerContext ctx, I128? n, int data) + { + ctx.Db.unique_option_i128.Insert(new UniqueOptionI128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i128(ReducerContext ctx, I128? n, int data) + { + ctx.Db.unique_option_i128.Delete(new UniqueOptionI128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i128(ReducerContext ctx, I128? n, int data) + { + ctx.Db.unique_option_i128.n.Delete(n); + ctx.Db.unique_option_i128.Insert(new UniqueOptionI128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i128(ReducerContext ctx, I128? n) + { + ctx.Db.unique_option_i128.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i256", Public = true)] + public partial struct UniqueOptionI256 + { + [SpacetimeDB.Unique] + public I256? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i256(ReducerContext ctx, I256? n, int data) + { + ctx.Db.unique_option_i256.Insert(new UniqueOptionI256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i256(ReducerContext ctx, I256? n, int data) + { + ctx.Db.unique_option_i256.Delete(new UniqueOptionI256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i256(ReducerContext ctx, I256? n, int data) + { + ctx.Db.unique_option_i256.n.Delete(n); + ctx.Db.unique_option_i256.Insert(new UniqueOptionI256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i256(ReducerContext ctx, I256? n) + { + ctx.Db.unique_option_i256.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_bool", Public = true)] + public partial struct UniqueOptionBool + { + [SpacetimeDB.Unique] + public bool? b; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_bool(ReducerContext ctx, bool? b, int data) + { + ctx.Db.unique_option_bool.Insert(new UniqueOptionBool { b = b, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_bool(ReducerContext ctx, bool? b, int data) + { + ctx.Db.unique_option_bool.Delete(new UniqueOptionBool { b = b, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_bool(ReducerContext ctx, bool? b, int data) + { + ctx.Db.unique_option_bool.b.Delete(b); + ctx.Db.unique_option_bool.Insert(new UniqueOptionBool { b = b, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_bool(ReducerContext ctx, bool? b) + { + ctx.Db.unique_option_bool.b.Delete(b); + } + + [SpacetimeDB.Table(Accessor = "unique_option_string", Public = true)] + public partial struct UniqueOptionString + { + [SpacetimeDB.Unique] + public string? s; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_string(ReducerContext ctx, string? s, int data) + { + ctx.Db.unique_option_string.Insert(new UniqueOptionString { s = s, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_string(ReducerContext ctx, string? s, int data) + { + ctx.Db.unique_option_string.Delete(new UniqueOptionString { s = s, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_string(ReducerContext ctx, string? s, int data) + { + ctx.Db.unique_option_string.s.Delete(s); + ctx.Db.unique_option_string.Insert(new UniqueOptionString { s = s, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_string(ReducerContext ctx, string? s) + { + ctx.Db.unique_option_string.s.Delete(s); + } + + [SpacetimeDB.Table(Accessor = "unique_option_identity", Public = true)] + public partial struct UniqueOptionIdentity + { + [SpacetimeDB.Unique] + public Identity? i; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_identity(ReducerContext ctx, Identity? i, int data) + { + ctx.Db.unique_option_identity.Insert(new UniqueOptionIdentity { i = i, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_identity(ReducerContext ctx, Identity? i, int data) + { + ctx.Db.unique_option_identity.Delete(new UniqueOptionIdentity { i = i, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_identity(ReducerContext ctx, Identity? i, int data) + { + ctx.Db.unique_option_identity.i.Delete(i); + ctx.Db.unique_option_identity.Insert(new UniqueOptionIdentity { i = i, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_identity(ReducerContext ctx, Identity? i) + { + ctx.Db.unique_option_identity.i.Delete(i); + } + + [SpacetimeDB.Table(Accessor = "unique_option_connection_id", Public = true)] + public partial struct UniqueOptionConnectionId + { + [SpacetimeDB.Unique] + public ConnectionId? a; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_connection_id(ReducerContext ctx, ConnectionId? a, int data) + { + ctx.Db.unique_option_connection_id.Insert(new UniqueOptionConnectionId { a = a, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_connection_id(ReducerContext ctx, ConnectionId? a, int data) + { + ctx.Db.unique_option_connection_id.Delete(new UniqueOptionConnectionId { a = a, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_connection_id(ReducerContext ctx, ConnectionId? a, int data) + { + ctx.Db.unique_option_connection_id.a.Delete(a); + ctx.Db.unique_option_connection_id.Insert(new UniqueOptionConnectionId { a = a, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_connection_id(ReducerContext ctx, ConnectionId? a) + { + ctx.Db.unique_option_connection_id.a.Delete(a); + } + + [SpacetimeDB.Table(Accessor = "unique_option_uuid", Public = true)] + public partial struct UniqueOptionUuid + { + [SpacetimeDB.Unique] + public Uuid? u; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_uuid(ReducerContext ctx, Uuid? u, int data) + { + ctx.Db.unique_option_uuid.Insert(new UniqueOptionUuid { u = u, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_uuid(ReducerContext ctx, Uuid? u, int data) + { + ctx.Db.unique_option_uuid.Delete(new UniqueOptionUuid { u = u, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_uuid(ReducerContext ctx, Uuid? u, int data) + { + ctx.Db.unique_option_uuid.u.Delete(u); + ctx.Db.unique_option_uuid.Insert(new UniqueOptionUuid { u = u, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_uuid(ReducerContext ctx, Uuid? u) + { + ctx.Db.unique_option_uuid.u.Delete(u); + } + [SpacetimeDB.Table(Accessor = "pk_u8", Public = true)] public partial struct PkU8 { @@ -1383,6 +2394,12 @@ public static void insert_pk_u8(ReducerContext ctx, byte n, int data) ctx.Db.pk_u8.Insert(new PkU8 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u8(ReducerContext ctx, byte n, int data) + { + ctx.Db.pk_u8.Delete(new PkU8 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u8(ReducerContext ctx, byte n, int data) { @@ -1410,6 +2427,12 @@ public static void insert_pk_u16(ReducerContext ctx, ushort n, int data) ctx.Db.pk_u16.Insert(new PkU16 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u16(ReducerContext ctx, ushort n, int data) + { + ctx.Db.pk_u16.Delete(new PkU16 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u16(ReducerContext ctx, ushort n, int data) { @@ -1437,6 +2460,12 @@ public static void insert_pk_u32(ReducerContext ctx, uint n, int data) ctx.Db.pk_u32.Insert(new PkU32 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u32(ReducerContext ctx, uint n, int data) + { + ctx.Db.pk_u32.Delete(new PkU32 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u32(ReducerContext ctx, uint n, int data) { @@ -1471,6 +2500,12 @@ public static void insert_pk_u32_two(ReducerContext ctx, uint n, int data) ctx.Db.pk_u32_two.Insert(new PkU32Two { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u32_two(ReducerContext ctx, uint n, int data) + { + ctx.Db.pk_u32_two.Delete(new PkU32Two { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u32_two(ReducerContext ctx, uint n, int data) { @@ -1498,6 +2533,12 @@ public static void insert_pk_u64(ReducerContext ctx, ulong n, int data) ctx.Db.pk_u64.Insert(new PkU64 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u64(ReducerContext ctx, ulong n, int data) + { + ctx.Db.pk_u64.Delete(new PkU64 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u64(ReducerContext ctx, ulong n, int data) { @@ -1525,6 +2566,12 @@ public static void insert_pk_u128(ReducerContext ctx, U128 n, int data) ctx.Db.pk_u128.Insert(new PkU128 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u128(ReducerContext ctx, U128 n, int data) + { + ctx.Db.pk_u128.Delete(new PkU128 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u128(ReducerContext ctx, U128 n, int data) { @@ -1552,6 +2599,12 @@ public static void insert_pk_u256(ReducerContext ctx, U256 n, int data) ctx.Db.pk_u256.Insert(new PkU256 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u256(ReducerContext ctx, U256 n, int data) + { + ctx.Db.pk_u256.Delete(new PkU256 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u256(ReducerContext ctx, U256 n, int data) { @@ -1579,6 +2632,12 @@ public static void insert_pk_i8(ReducerContext ctx, sbyte n, int data) ctx.Db.pk_i8.Insert(new PkI8 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i8(ReducerContext ctx, sbyte n, int data) + { + ctx.Db.pk_i8.Delete(new PkI8 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i8(ReducerContext ctx, sbyte n, int data) { @@ -1606,6 +2665,12 @@ public static void insert_pk_i16(ReducerContext ctx, short n, int data) ctx.Db.pk_i16.Insert(new PkI16 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i16(ReducerContext ctx, short n, int data) + { + ctx.Db.pk_i16.Delete(new PkI16 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i16(ReducerContext ctx, short n, int data) { @@ -1633,6 +2698,12 @@ public static void insert_pk_i32(ReducerContext ctx, int n, int data) ctx.Db.pk_i32.Insert(new PkI32 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i32(ReducerContext ctx, int n, int data) + { + ctx.Db.pk_i32.Delete(new PkI32 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i32(ReducerContext ctx, int n, int data) { @@ -1660,6 +2731,12 @@ public static void insert_pk_i64(ReducerContext ctx, long n, int data) ctx.Db.pk_i64.Insert(new PkI64 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i64(ReducerContext ctx, long n, int data) + { + ctx.Db.pk_i64.Delete(new PkI64 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i64(ReducerContext ctx, long n, int data) { @@ -1687,6 +2764,12 @@ public static void insert_pk_i128(ReducerContext ctx, I128 n, int data) ctx.Db.pk_i128.Insert(new PkI128 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i128(ReducerContext ctx, I128 n, int data) + { + ctx.Db.pk_i128.Delete(new PkI128 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i128(ReducerContext ctx, I128 n, int data) { @@ -1714,6 +2797,12 @@ public static void insert_pk_i256(ReducerContext ctx, I256 n, int data) ctx.Db.pk_i256.Insert(new PkI256 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i256(ReducerContext ctx, I256 n, int data) + { + ctx.Db.pk_i256.Delete(new PkI256 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i256(ReducerContext ctx, I256 n, int data) { @@ -1741,6 +2830,12 @@ public static void insert_pk_bool(ReducerContext ctx, bool b, int data) ctx.Db.pk_bool.Insert(new PkBool { b = b, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_bool(ReducerContext ctx, bool b, int data) + { + ctx.Db.pk_bool.Delete(new PkBool { b = b, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_bool(ReducerContext ctx, bool b, int data) { @@ -1768,6 +2863,12 @@ public static void insert_pk_string(ReducerContext ctx, string s, int data) ctx.Db.pk_string.Insert(new PkString { s = s, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_string(ReducerContext ctx, string s, int data) + { + ctx.Db.pk_string.Delete(new PkString { s = s, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_string(ReducerContext ctx, string s, int data) { @@ -1795,6 +2896,12 @@ public static void insert_pk_identity(ReducerContext ctx, Identity i, int data) ctx.Db.pk_identity.Insert(new PkIdentity { i = i, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_identity(ReducerContext ctx, Identity i, int data) + { + ctx.Db.pk_identity.Delete(new PkIdentity { i = i, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_identity(ReducerContext ctx, Identity i, int data) { @@ -1822,6 +2929,12 @@ public static void insert_pk_connection_id(ReducerContext ctx, ConnectionId a, i ctx.Db.pk_connection_id.Insert(new PkConnectionId { a = a, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_connection_id(ReducerContext ctx, ConnectionId a, int data) + { + ctx.Db.pk_connection_id.Delete(new PkConnectionId { a = a, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_connection_id(ReducerContext ctx, ConnectionId a, int data) { @@ -1849,6 +2962,12 @@ public static void insert_pk_uuid(ReducerContext ctx, Uuid u, int data) ctx.Db.pk_uuid.Insert(new PkUuid { u = u, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_uuid(ReducerContext ctx, Uuid u, int data) + { + ctx.Db.pk_uuid.Delete(new PkUuid { u = u, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_uuid(ReducerContext ctx, Uuid u, int data) { diff --git a/modules/sdk-test-ts/src/index.ts b/modules/sdk-test-ts/src/index.ts index 257086782f0..78dc28c9290 100644 --- a/modules/sdk-test-ts/src/index.ts +++ b/modules/sdk-test-ts/src/index.ts @@ -112,13 +112,17 @@ function tbl( ops: { insert?: string; delete?: string; + delete_all?: string; insert_or_panic?: string; update_by?: [string, keyof Row]; update_non_pk_by?: [string, keyof Row]; delete_by?: [string, keyof Row]; }, row: Row -): TableWithReducers>> { +): TableWithReducers< + Accessor, + ReturnType> +> { const t = table({ public: true }, row); return { table: t, @@ -134,6 +138,11 @@ function tbl( (ctx.db[accessor] as any).delete({ ...args }); }); } + if (ops.delete_all) { + exports[ops.delete_all] = spacetimedb.reducer(row, (ctx, args) => { + (ctx.db[accessor] as any).delete({ ...args }); + }); + } if (ops.insert_or_panic) { exports[ops.insert_or_panic] = spacetimedb.reducer(row, (ctx, args) => { (ctx.db[accessor] as any).insert({ ...args }); @@ -168,34 +177,94 @@ function tbl( // Tables holding a single value. const singleValTables = { - oneU8: tbl('oneU8', { insert: 'insert_one_u8' }, { n: t.u8() }), - oneU16: tbl('oneU16', { insert: 'insert_one_u16' }, { n: t.u16() }), - oneU32: tbl('oneU32', { insert: 'insert_one_u32' }, { n: t.u32() }), - oneU64: tbl('oneU64', { insert: 'insert_one_u64' }, { n: t.u64() }), - oneU128: tbl('oneU128', { insert: 'insert_one_u128' }, { n: t.u128() }), - oneU256: tbl('oneU256', { insert: 'insert_one_u256' }, { n: t.u256() }), + oneU8: tbl( + 'oneU8', + { insert: 'insert_one_u8', delete_all: 'delete_all_one_u8' }, + { n: t.u8() } + ), + oneU16: tbl( + 'oneU16', + { insert: 'insert_one_u16', delete_all: 'delete_all_one_u16' }, + { n: t.u16() } + ), + oneU32: tbl( + 'oneU32', + { insert: 'insert_one_u32', delete_all: 'delete_all_one_u32' }, + { n: t.u32() } + ), + oneU64: tbl( + 'oneU64', + { insert: 'insert_one_u64', delete_all: 'delete_all_one_u64' }, + { n: t.u64() } + ), + oneU128: tbl( + 'oneU128', + { insert: 'insert_one_u128', delete_all: 'delete_all_one_u128' }, + { n: t.u128() } + ), + oneU256: tbl( + 'oneU256', + { insert: 'insert_one_u256', delete_all: 'delete_all_one_u256' }, + { n: t.u256() } + ), - oneI8: tbl('oneI8', { insert: 'insert_one_i8' }, { n: t.i8() }), - oneI16: tbl('oneI16', { insert: 'insert_one_i16' }, { n: t.i16() }), - oneI32: tbl('oneI32', { insert: 'insert_one_i32' }, { n: t.i32() }), - oneI64: tbl('oneI64', { insert: 'insert_one_i64' }, { n: t.i64() }), - oneI128: tbl('oneI128', { insert: 'insert_one_i128' }, { n: t.i128() }), - oneI256: tbl('oneI256', { insert: 'insert_one_i256' }, { n: t.i256() }), + oneI8: tbl( + 'oneI8', + { insert: 'insert_one_i8', delete_all: 'delete_all_one_i8' }, + { n: t.i8() } + ), + oneI16: tbl( + 'oneI16', + { insert: 'insert_one_i16', delete_all: 'delete_all_one_i16' }, + { n: t.i16() } + ), + oneI32: tbl( + 'oneI32', + { insert: 'insert_one_i32', delete_all: 'delete_all_one_i32' }, + { n: t.i32() } + ), + oneI64: tbl( + 'oneI64', + { insert: 'insert_one_i64', delete_all: 'delete_all_one_i64' }, + { n: t.i64() } + ), + oneI128: tbl( + 'oneI128', + { insert: 'insert_one_i128', delete_all: 'delete_all_one_i128' }, + { n: t.i128() } + ), + oneI256: tbl( + 'oneI256', + { insert: 'insert_one_i256', delete_all: 'delete_all_one_i256' }, + { n: t.i256() } + ), - oneBool: tbl('oneBool', { insert: 'insert_one_bool' }, { b: t.bool() }), + oneBool: tbl( + 'oneBool', + { insert: 'insert_one_bool', delete_all: 'delete_all_one_bool' }, + { b: t.bool() } + ), - oneF32: tbl('oneF32', { insert: 'insert_one_f32' }, { f: t.f32() }), - oneF64: tbl('oneF64', { insert: 'insert_one_f64' }, { f: t.f64() }), + oneF32: tbl( + 'oneF32', + { insert: 'insert_one_f32', delete_all: 'delete_all_one_f32' }, + { f: t.f32() } + ), + oneF64: tbl( + 'oneF64', + { insert: 'insert_one_f64', delete_all: 'delete_all_one_f64' }, + { f: t.f64() } + ), oneString: tbl( 'oneString', - { insert: 'insert_one_string' }, + { insert: 'insert_one_string', delete_all: 'delete_all_one_string' }, { s: t.string() } ), oneIdentity: tbl( 'oneIdentity', - { insert: 'insert_one_identity' }, + { insert: 'insert_one_identity', delete_all: 'delete_all_one_identity' }, { i: t.identity() } ), oneConnectionId: tbl( @@ -204,129 +273,159 @@ const singleValTables = { { a: t.connectionId() } ), - oneUuid: tbl('oneUuid', { insert: 'insert_one_uuid' }, { u: t.uuid() }), + oneUuid: tbl( + 'oneUuid', + { insert: 'insert_one_uuid', delete_all: 'delete_all_one_uuid' }, + { u: t.uuid() } + ), oneTimestamp: tbl( 'oneTimestamp', - { insert: 'insert_one_timestamp' }, + { insert: 'insert_one_timestamp', delete_all: 'delete_all_one_timestamp' }, { t: t.timestamp() } ), oneSimpleEnum: tbl( 'oneSimpleEnum', - { insert: 'insert_one_simple_enum' }, + { + insert: 'insert_one_simple_enum', + delete_all: 'delete_all_one_simple_enum', + }, { e: SimpleEnum } ), oneEnumWithPayload: tbl( 'oneEnumWithPayload', - { insert: 'insert_one_enum_with_payload' }, + { + insert: 'insert_one_enum_with_payload', + delete_all: 'delete_all_one_enum_with_payload', + }, { e: EnumWithPayload } ), oneUnitStruct: tbl( 'oneUnitStruct', - { insert: 'insert_one_unit_struct' }, + { + insert: 'insert_one_unit_struct', + delete_all: 'delete_all_one_unit_struct', + }, { s: UnitStruct } ), oneByteStruct: tbl( 'oneByteStruct', - { insert: 'insert_one_byte_struct' }, + { + insert: 'insert_one_byte_struct', + delete_all: 'delete_all_one_byte_struct', + }, { s: ByteStruct } ), oneEveryPrimitiveStruct: tbl( 'oneEveryPrimitiveStruct', - { insert: 'insert_one_every_primitive_struct' }, + { + insert: 'insert_one_every_primitive_struct', + delete_all: 'delete_all_one_every_primitive_struct', + }, { s: EveryPrimitiveStruct } ), oneEveryVecStruct: tbl( 'oneEveryVecStruct', - { insert: 'insert_one_every_vec_struct' }, + { + insert: 'insert_one_every_vec_struct', + delete_all: 'delete_all_one_every_vec_struct', + }, { s: EveryVecStruct } ), } as const; // Tables holding a Vec of various types. const vecTables = { - vecU8: tbl('vecU8', { insert: 'insert_vec_u8' }, { n: t.array(t.u8()) }), + vecU8: tbl( + 'vecU8', + { insert: 'insert_vec_u8', delete_all: 'delete_all_vec_u8' }, + { n: t.array(t.u8()) } + ), vecU16: tbl( 'vecU16', - { insert: 'insert_vec_u16' }, + { insert: 'insert_vec_u16', delete_all: 'delete_all_vec_u16' }, { n: t.array(t.u16()) } ), vecU32: tbl( 'vecU32', - { insert: 'insert_vec_u32' }, + { insert: 'insert_vec_u32', delete_all: 'delete_all_vec_u32' }, { n: t.array(t.u32()) } ), vecU64: tbl( 'vecU64', - { insert: 'insert_vec_u64' }, + { insert: 'insert_vec_u64', delete_all: 'delete_all_vec_u64' }, { n: t.array(t.u64()) } ), vecU128: tbl( 'vecU128', - { insert: 'insert_vec_u128' }, + { insert: 'insert_vec_u128', delete_all: 'delete_all_vec_u128' }, { n: t.array(t.u128()) } ), vecU256: tbl( 'vecU256', - { insert: 'insert_vec_u256' }, + { insert: 'insert_vec_u256', delete_all: 'delete_all_vec_u256' }, { n: t.array(t.u256()) } ), - vecI8: tbl('vecI8', { insert: 'insert_vec_i8' }, { n: t.array(t.i8()) }), + vecI8: tbl( + 'vecI8', + { insert: 'insert_vec_i8', delete_all: 'delete_all_vec_i8' }, + { n: t.array(t.i8()) } + ), vecI16: tbl( 'vecI16', - { insert: 'insert_vec_i16' }, + { insert: 'insert_vec_i16', delete_all: 'delete_all_vec_i16' }, { n: t.array(t.i16()) } ), vecI32: tbl( 'vecI32', - { insert: 'insert_vec_i32' }, + { insert: 'insert_vec_i32', delete_all: 'delete_all_vec_i32' }, { n: t.array(t.i32()) } ), vecI64: tbl( 'vecI64', - { insert: 'insert_vec_i64' }, + { insert: 'insert_vec_i64', delete_all: 'delete_all_vec_i64' }, { n: t.array(t.i64()) } ), vecI128: tbl( 'vecI128', - { insert: 'insert_vec_i128' }, + { insert: 'insert_vec_i128', delete_all: 'delete_all_vec_i128' }, { n: t.array(t.i128()) } ), vecI256: tbl( 'vecI256', - { insert: 'insert_vec_i256' }, + { insert: 'insert_vec_i256', delete_all: 'delete_all_vec_i256' }, { n: t.array(t.i256()) } ), vecBool: tbl( 'vecBool', - { insert: 'insert_vec_bool' }, + { insert: 'insert_vec_bool', delete_all: 'delete_all_vec_bool' }, { b: t.array(t.bool()) } ), vecF32: tbl( 'vecF32', - { insert: 'insert_vec_f32' }, + { insert: 'insert_vec_f32', delete_all: 'delete_all_vec_f32' }, { f: t.array(t.f32()) } ), vecF64: tbl( 'vecF64', - { insert: 'insert_vec_f64' }, + { insert: 'insert_vec_f64', delete_all: 'delete_all_vec_f64' }, { f: t.array(t.f64()) } ), vecString: tbl( 'vecString', - { insert: 'insert_vec_string' }, + { insert: 'insert_vec_string', delete_all: 'delete_all_vec_string' }, { s: t.array(t.string()) } ), vecIdentity: tbl( 'vecIdentity', - { insert: 'insert_vec_identity' }, + { insert: 'insert_vec_identity', delete_all: 'delete_all_vec_identity' }, { i: t.array(t.identity()) } ), vecConnectionId: tbl( @@ -337,45 +436,63 @@ const vecTables = { vecTimestamp: tbl( 'vecTimestamp', - { insert: 'insert_vec_timestamp' }, + { insert: 'insert_vec_timestamp', delete_all: 'delete_all_vec_timestamp' }, { t: t.array(t.timestamp()) } ), vecUuid: tbl( 'vecUuid', - { insert: 'insert_vec_uuid' }, + { insert: 'insert_vec_uuid', delete_all: 'delete_all_vec_uuid' }, { u: t.array(t.uuid()) } ), vecSimpleEnum: tbl( 'vecSimpleEnum', - { insert: 'insert_vec_simple_enum' }, + { + insert: 'insert_vec_simple_enum', + delete_all: 'delete_all_vec_simple_enum', + }, { e: t.array(SimpleEnum) } ), vecEnumWithPayload: tbl( 'vecEnumWithPayload', - { insert: 'insert_vec_enum_with_payload' }, + { + insert: 'insert_vec_enum_with_payload', + delete_all: 'delete_all_vec_enum_with_payload', + }, { e: t.array(EnumWithPayload) } ), vecUnitStruct: tbl( 'vecUnitStruct', - { insert: 'insert_vec_unit_struct' }, + { + insert: 'insert_vec_unit_struct', + delete_all: 'delete_all_vec_unit_struct', + }, { s: t.array(UnitStruct) } ), vecByteStruct: tbl( 'vecByteStruct', - { insert: 'insert_vec_byte_struct' }, + { + insert: 'insert_vec_byte_struct', + delete_all: 'delete_all_vec_byte_struct', + }, { s: t.array(ByteStruct) } ), vecEveryPrimitiveStruct: tbl( 'vecEveryPrimitiveStruct', - { insert: 'insert_vec_every_primitive_struct' }, + { + insert: 'insert_vec_every_primitive_struct', + delete_all: 'delete_all_vec_every_primitive_struct', + }, { s: t.array(EveryPrimitiveStruct) } ), vecEveryVecStruct: tbl( 'vecEveryVecStruct', - { insert: 'insert_vec_every_vec_struct' }, + { + insert: 'insert_vec_every_vec_struct', + delete_all: 'delete_all_vec_every_vec_struct', + }, { s: t.array(EveryVecStruct) } ), } as const; @@ -384,37 +501,49 @@ const vecTables = { const optionTables = { optionI32: tbl( 'optionI32', - { insert: 'insert_option_i32' }, + { insert: 'insert_option_i32', delete_all: 'delete_all_option_i32' }, { n: t.option(t.i32()) } ), optionString: tbl( 'optionString', - { insert: 'insert_option_string' }, + { insert: 'insert_option_string', delete_all: 'delete_all_option_string' }, { s: t.option(t.string()) } ), optionIdentity: tbl( 'optionIdentity', - { insert: 'insert_option_identity' }, + { + insert: 'insert_option_identity', + delete_all: 'delete_all_option_identity', + }, { i: t.option(t.identity()) } ), optionUuid: tbl( 'optionUuid', - { insert: 'insert_option_uuid' }, + { insert: 'insert_option_uuid', delete_all: 'delete_all_option_uuid' }, { u: t.option(t.uuid()) } ), optionSimpleEnum: tbl( 'optionSimpleEnum', - { insert: 'insert_option_simple_enum' }, + { + insert: 'insert_option_simple_enum', + delete_all: 'delete_all_option_simple_enum', + }, { e: t.option(SimpleEnum) } ), optionEveryPrimitiveStruct: tbl( 'optionEveryPrimitiveStruct', - { insert: 'insert_option_every_primitive_struct' }, + { + insert: 'insert_option_every_primitive_struct', + delete_all: 'delete_all_option_every_primitive_struct', + }, { s: t.option(EveryPrimitiveStruct) } ), optionVecOptionI32: tbl( 'optionVecOptionI32', - { insert: 'insert_option_vec_option_i32' }, + { + insert: 'insert_option_vec_option_i32', + delete_all: 'delete_all_option_vec_option_i32', + }, { v: t.option(t.array(t.option(t.i32()))) } ), } as const; @@ -460,6 +589,8 @@ const uniqueTables = { 'uniqueU8', { insert_or_panic: 'insert_unique_u8', + + delete_all: 'delete_all_unique_u8', update_non_pk_by: ['update_unique_u8', 'n'], delete_by: ['delete_unique_u8', 'n'], }, @@ -470,6 +601,8 @@ const uniqueTables = { 'uniqueU16', { insert_or_panic: 'insert_unique_u16', + + delete_all: 'delete_all_unique_u16', update_non_pk_by: ['update_unique_u16', 'n'], delete_by: ['delete_unique_u16', 'n'], }, @@ -480,6 +613,8 @@ const uniqueTables = { 'uniqueU32', { insert_or_panic: 'insert_unique_u32', + + delete_all: 'delete_all_unique_u32', update_non_pk_by: ['update_unique_u32', 'n'], delete_by: ['delete_unique_u32', 'n'], }, @@ -490,6 +625,8 @@ const uniqueTables = { 'uniqueU64', { insert_or_panic: 'insert_unique_u64', + + delete_all: 'delete_all_unique_u64', update_non_pk_by: ['update_unique_u64', 'n'], delete_by: ['delete_unique_u64', 'n'], }, @@ -500,6 +637,8 @@ const uniqueTables = { 'uniqueU128', { insert_or_panic: 'insert_unique_u128', + + delete_all: 'delete_all_unique_u128', update_non_pk_by: ['update_unique_u128', 'n'], delete_by: ['delete_unique_u128', 'n'], }, @@ -510,6 +649,8 @@ const uniqueTables = { 'uniqueU256', { insert_or_panic: 'insert_unique_u256', + + delete_all: 'delete_all_unique_u256', update_non_pk_by: ['update_unique_u256', 'n'], delete_by: ['delete_unique_u256', 'n'], }, @@ -520,6 +661,8 @@ const uniqueTables = { 'uniqueI8', { insert_or_panic: 'insert_unique_i8', + + delete_all: 'delete_all_unique_i8', update_non_pk_by: ['update_unique_i8', 'n'], delete_by: ['delete_unique_i8', 'n'], }, @@ -530,6 +673,8 @@ const uniqueTables = { 'uniqueI16', { insert_or_panic: 'insert_unique_i16', + + delete_all: 'delete_all_unique_i16', update_non_pk_by: ['update_unique_i16', 'n'], delete_by: ['delete_unique_i16', 'n'], }, @@ -540,6 +685,8 @@ const uniqueTables = { 'uniqueI32', { insert_or_panic: 'insert_unique_i32', + + delete_all: 'delete_all_unique_i32', update_non_pk_by: ['update_unique_i32', 'n'], delete_by: ['delete_unique_i32', 'n'], }, @@ -550,6 +697,8 @@ const uniqueTables = { 'uniqueI64', { insert_or_panic: 'insert_unique_i64', + + delete_all: 'delete_all_unique_i64', update_non_pk_by: ['update_unique_i64', 'n'], delete_by: ['delete_unique_i64', 'n'], }, @@ -560,6 +709,8 @@ const uniqueTables = { 'uniqueI128', { insert_or_panic: 'insert_unique_i128', + + delete_all: 'delete_all_unique_i128', update_non_pk_by: ['update_unique_i128', 'n'], delete_by: ['delete_unique_i128', 'n'], }, @@ -570,6 +721,8 @@ const uniqueTables = { 'uniqueI256', { insert_or_panic: 'insert_unique_i256', + + delete_all: 'delete_all_unique_i256', update_non_pk_by: ['update_unique_i256', 'n'], delete_by: ['delete_unique_i256', 'n'], }, @@ -580,6 +733,8 @@ const uniqueTables = { 'uniqueBool', { insert_or_panic: 'insert_unique_bool', + + delete_all: 'delete_all_unique_bool', update_non_pk_by: ['update_unique_bool', 'b'], delete_by: ['delete_unique_bool', 'b'], }, @@ -590,6 +745,8 @@ const uniqueTables = { 'uniqueString', { insert_or_panic: 'insert_unique_string', + + delete_all: 'delete_all_unique_string', update_non_pk_by: ['update_unique_string', 's'], delete_by: ['delete_unique_string', 's'], }, @@ -600,6 +757,8 @@ const uniqueTables = { 'uniqueIdentity', { insert_or_panic: 'insert_unique_identity', + + delete_all: 'delete_all_unique_identity', update_non_pk_by: ['update_unique_identity', 'i'], delete_by: ['delete_unique_identity', 'i'], }, @@ -610,6 +769,8 @@ const uniqueTables = { 'uniqueConnectionId', { insert_or_panic: 'insert_unique_connection_id', + + delete_all: 'delete_all_unique_connection_id', update_non_pk_by: ['update_unique_connection_id', 'a'], delete_by: ['delete_unique_connection_id', 'a'], }, @@ -620,6 +781,8 @@ const uniqueTables = { 'uniqueUuid', { insert_or_panic: 'insert_unique_uuid', + + delete_all: 'delete_all_unique_uuid', update_non_pk_by: ['update_unique_uuid', 'u'], delete_by: ['delete_unique_uuid', 'u'], }, @@ -627,6 +790,197 @@ const uniqueTables = { ), } as const; +// Tables mapping a unique Option for some T to a boring i32 payload. +const uniqueOptionTables = { + uniqueOptionU8: tbl( + 'uniqueOptionU8', + { + insert_or_panic: 'insert_unique_option_u8', + + delete_all: 'delete_all_unique_option_u8', + update_non_pk_by: ['update_unique_option_u8', 'n'], + delete_by: ['delete_unique_option_u8', 'n'], + }, + { n: t.option(t.u8()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU16: tbl( + 'uniqueOptionU16', + { + insert_or_panic: 'insert_unique_option_u16', + + delete_all: 'delete_all_unique_option_u16', + update_non_pk_by: ['update_unique_option_u16', 'n'], + delete_by: ['delete_unique_option_u16', 'n'], + }, + { n: t.option(t.u16()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU32: tbl( + 'uniqueOptionU32', + { + insert_or_panic: 'insert_unique_option_u32', + + delete_all: 'delete_all_unique_option_u32', + update_non_pk_by: ['update_unique_option_u32', 'n'], + delete_by: ['delete_unique_option_u32', 'n'], + }, + { n: t.option(t.u32()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU64: tbl( + 'uniqueOptionU64', + { + insert_or_panic: 'insert_unique_option_u64', + + delete_all: 'delete_all_unique_option_u64', + update_non_pk_by: ['update_unique_option_u64', 'n'], + delete_by: ['delete_unique_option_u64', 'n'], + }, + { n: t.option(t.u64()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU128: tbl( + 'uniqueOptionU128', + { + insert_or_panic: 'insert_unique_option_u128', + + delete_all: 'delete_all_unique_option_u128', + update_non_pk_by: ['update_unique_option_u128', 'n'], + delete_by: ['delete_unique_option_u128', 'n'], + }, + { n: t.option(t.u128()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU256: tbl( + 'uniqueOptionU256', + { + insert_or_panic: 'insert_unique_option_u256', + + delete_all: 'delete_all_unique_option_u256', + update_non_pk_by: ['update_unique_option_u256', 'n'], + delete_by: ['delete_unique_option_u256', 'n'], + }, + { n: t.option(t.u256()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI8: tbl( + 'uniqueOptionI8', + { + insert_or_panic: 'insert_unique_option_i8', + + delete_all: 'delete_all_unique_option_i8', + update_non_pk_by: ['update_unique_option_i8', 'n'], + delete_by: ['delete_unique_option_i8', 'n'], + }, + { n: t.option(t.i8()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI16: tbl( + 'uniqueOptionI16', + { + insert_or_panic: 'insert_unique_option_i16', + + delete_all: 'delete_all_unique_option_i16', + update_non_pk_by: ['update_unique_option_i16', 'n'], + delete_by: ['delete_unique_option_i16', 'n'], + }, + { n: t.option(t.i16()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI32: tbl( + 'uniqueOptionI32', + { + insert_or_panic: 'insert_unique_option_i32', + + delete_all: 'delete_all_unique_option_i32', + update_non_pk_by: ['update_unique_option_i32', 'n'], + delete_by: ['delete_unique_option_i32', 'n'], + }, + { n: t.option(t.i32()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI64: tbl( + 'uniqueOptionI64', + { + insert_or_panic: 'insert_unique_option_i64', + + delete_all: 'delete_all_unique_option_i64', + update_non_pk_by: ['update_unique_option_i64', 'n'], + delete_by: ['delete_unique_option_i64', 'n'], + }, + { n: t.option(t.i64()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI128: tbl( + 'uniqueOptionI128', + { + insert_or_panic: 'insert_unique_option_i128', + + delete_all: 'delete_all_unique_option_i128', + update_non_pk_by: ['update_unique_option_i128', 'n'], + delete_by: ['delete_unique_option_i128', 'n'], + }, + { n: t.option(t.i128()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI256: tbl( + 'uniqueOptionI256', + { + insert_or_panic: 'insert_unique_option_i256', + + delete_all: 'delete_all_unique_option_i256', + update_non_pk_by: ['update_unique_option_i256', 'n'], + delete_by: ['delete_unique_option_i256', 'n'], + }, + { n: t.option(t.i256()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionBool: tbl( + 'uniqueOptionBool', + { + insert_or_panic: 'insert_unique_option_bool', + + delete_all: 'delete_all_unique_option_bool', + update_non_pk_by: ['update_unique_option_bool', 'b'], + delete_by: ['delete_unique_option_bool', 'b'], + }, + { b: t.option(t.bool()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionString: tbl( + 'uniqueOptionString', + { + insert_or_panic: 'insert_unique_option_string', + + delete_all: 'delete_all_unique_option_string', + update_non_pk_by: ['update_unique_option_string', 's'], + delete_by: ['delete_unique_option_string', 's'], + }, + { s: t.option(t.string()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionIdentity: tbl( + 'uniqueOptionIdentity', + { + insert_or_panic: 'insert_unique_option_identity', + + delete_all: 'delete_all_unique_option_identity', + update_non_pk_by: ['update_unique_option_identity', 'i'], + delete_by: ['delete_unique_option_identity', 'i'], + }, + { i: t.option(t.identity()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionConnectionId: tbl( + 'uniqueOptionConnectionId', + { + insert_or_panic: 'insert_unique_option_connection_id', + + delete_all: 'delete_all_unique_option_connection_id', + update_non_pk_by: ['update_unique_option_connection_id', 'a'], + delete_by: ['delete_unique_option_connection_id', 'a'], + }, + { a: t.option(t.connectionId()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionUuid: tbl( + 'uniqueOptionUuid', + { + insert_or_panic: 'insert_unique_option_uuid', + + delete_all: 'delete_all_unique_option_uuid', + update_non_pk_by: ['update_unique_option_uuid', 'u'], + delete_by: ['delete_unique_option_uuid', 'u'], + }, + { u: t.option(t.uuid()).index('btree').unique(), data: t.i32() } + ), +} as const; + // Tables mapping a primary key to a boring i32 payload. // This allows us to test update and delete events. const pkTables = { @@ -634,6 +988,8 @@ const pkTables = { 'pkU8', { insert_or_panic: 'insert_pk_u8', + + delete_all: 'delete_all_pk_u8', update_by: ['update_pk_u8', 'n'], delete_by: ['delete_pk_u8', 'n'], }, @@ -644,6 +1000,8 @@ const pkTables = { 'pkU16', { insert_or_panic: 'insert_pk_u16', + + delete_all: 'delete_all_pk_u16', update_by: ['update_pk_u16', 'n'], delete_by: ['delete_pk_u16', 'n'], }, @@ -654,6 +1012,8 @@ const pkTables = { 'pkU32', { insert_or_panic: 'insert_pk_u32', + + delete_all: 'delete_all_pk_u32', update_by: ['update_pk_u32', 'n'], delete_by: ['delete_pk_u32', 'n'], }, @@ -664,6 +1024,8 @@ const pkTables = { 'pkU32Two', { insert_or_panic: 'insert_pk_u32_two', + + delete_all: 'delete_all_pk_u32_two', update_by: ['update_pk_u32_two', 'n'], delete_by: ['delete_pk_u32_two', 'n'], }, @@ -674,6 +1036,8 @@ const pkTables = { 'pkU64', { insert_or_panic: 'insert_pk_u64', + + delete_all: 'delete_all_pk_u64', update_by: ['update_pk_u64', 'n'], delete_by: ['delete_pk_u64', 'n'], }, @@ -684,6 +1048,8 @@ const pkTables = { 'pkU128', { insert_or_panic: 'insert_pk_u128', + + delete_all: 'delete_all_pk_u128', update_by: ['update_pk_u128', 'n'], delete_by: ['delete_pk_u128', 'n'], }, @@ -694,6 +1060,8 @@ const pkTables = { 'pkU256', { insert_or_panic: 'insert_pk_u256', + + delete_all: 'delete_all_pk_u256', update_by: ['update_pk_u256', 'n'], delete_by: ['delete_pk_u256', 'n'], }, @@ -704,6 +1072,8 @@ const pkTables = { 'pkI8', { insert_or_panic: 'insert_pk_i8', + + delete_all: 'delete_all_pk_i8', update_by: ['update_pk_i8', 'n'], delete_by: ['delete_pk_i8', 'n'], }, @@ -714,6 +1084,8 @@ const pkTables = { 'pkI16', { insert_or_panic: 'insert_pk_i16', + + delete_all: 'delete_all_pk_i16', update_by: ['update_pk_i16', 'n'], delete_by: ['delete_pk_i16', 'n'], }, @@ -724,6 +1096,8 @@ const pkTables = { 'pkI32', { insert_or_panic: 'insert_pk_i32', + + delete_all: 'delete_all_pk_i32', update_by: ['update_pk_i32', 'n'], delete_by: ['delete_pk_i32', 'n'], }, @@ -734,6 +1108,8 @@ const pkTables = { 'pkI64', { insert_or_panic: 'insert_pk_i64', + + delete_all: 'delete_all_pk_i64', update_by: ['update_pk_i64', 'n'], delete_by: ['delete_pk_i64', 'n'], }, @@ -744,6 +1120,8 @@ const pkTables = { 'pkI128', { insert_or_panic: 'insert_pk_i128', + + delete_all: 'delete_all_pk_i128', update_by: ['update_pk_i128', 'n'], delete_by: ['delete_pk_i128', 'n'], }, @@ -754,6 +1132,8 @@ const pkTables = { 'pkI256', { insert_or_panic: 'insert_pk_i256', + + delete_all: 'delete_all_pk_i256', update_by: ['update_pk_i256', 'n'], delete_by: ['delete_pk_i256', 'n'], }, @@ -764,6 +1144,8 @@ const pkTables = { 'pkBool', { insert_or_panic: 'insert_pk_bool', + + delete_all: 'delete_all_pk_bool', update_by: ['update_pk_bool', 'b'], delete_by: ['delete_pk_bool', 'b'], }, @@ -774,6 +1156,8 @@ const pkTables = { 'pkString', { insert_or_panic: 'insert_pk_string', + + delete_all: 'delete_all_pk_string', update_by: ['update_pk_string', 's'], delete_by: ['delete_pk_string', 's'], }, @@ -784,6 +1168,8 @@ const pkTables = { 'pkIdentity', { insert_or_panic: 'insert_pk_identity', + + delete_all: 'delete_all_pk_identity', update_by: ['update_pk_identity', 'i'], delete_by: ['delete_pk_identity', 'i'], }, @@ -794,6 +1180,8 @@ const pkTables = { 'pkConnectionId', { insert_or_panic: 'insert_pk_connection_id', + + delete_all: 'delete_all_pk_connection_id', update_by: ['update_pk_connection_id', 'a'], delete_by: ['delete_pk_connection_id', 'a'], }, @@ -804,6 +1192,8 @@ const pkTables = { 'pkUuid', { insert_or_panic: 'insert_pk_uuid', + + delete_all: 'delete_all_pk_uuid', update_by: ['update_pk_uuid', 'u'], delete_by: ['delete_pk_uuid', 'u'], }, @@ -876,6 +1266,7 @@ const allTables = { ...optionTables, ...resultTables, ...uniqueTables, + ...uniqueOptionTables, ...pkTables, ...weirdTables, } as const; diff --git a/modules/sdk-test/src/lib.rs b/modules/sdk-test/src/lib.rs index 54f8b22b602..cfb9339b55c 100644 --- a/modules/sdk-test/src/lib.rs +++ b/modules/sdk-test/src/lib.rs @@ -495,6 +495,114 @@ define_tables! { } #[unique] u Uuid, data i32; } +// Tables mapping a unique `Option` for some `T` to a boring `i32` payload. +define_tables! { + UniqueOptionU8 { + insert_or_panic insert_unique_option_u8, delete_all delete_all_unique_option_u8, + update_non_pk_by update_unique_option_u8 = update_by_n(n), + delete_by delete_unique_option_u8 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + UniqueOptionU16 { + insert_or_panic insert_unique_option_u16, delete_all delete_all_unique_option_u16, + update_non_pk_by update_unique_option_u16 = update_by_n(n), + delete_by delete_unique_option_u16 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + UniqueOptionU32 { + insert_or_panic insert_unique_option_u32, delete_all delete_all_unique_option_u32, + update_non_pk_by update_unique_option_u32 = update_by_n(n), + delete_by delete_unique_option_u32 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + UniqueOptionU64 { + insert_or_panic insert_unique_option_u64, delete_all delete_all_unique_option_u64, + update_non_pk_by update_unique_option_u64 = update_by_n(n), + delete_by delete_unique_option_u64 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + UniqueOptionU128 { + insert_or_panic insert_unique_option_u128, delete_all delete_all_unique_option_u128, + update_non_pk_by update_unique_option_u128 = update_by_n(n), + delete_by delete_unique_option_u128 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + UniqueOptionU256 { + insert_or_panic insert_unique_option_u256, delete_all delete_all_unique_option_u256, + update_non_pk_by update_unique_option_u256 = update_by_n(n), + delete_by delete_unique_option_u256 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + + UniqueOptionI8 { + insert_or_panic insert_unique_option_i8, delete_all delete_all_unique_option_i8, + update_non_pk_by update_unique_option_i8 = update_by_n(n), + delete_by delete_unique_option_i8 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + + UniqueOptionI16 { + insert_or_panic insert_unique_option_i16, delete_all delete_all_unique_option_i16, + update_non_pk_by update_unique_option_i16 = update_by_n(n), + delete_by delete_unique_option_i16 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + UniqueOptionI32 { + insert_or_panic insert_unique_option_i32, delete_all delete_all_unique_option_i32, + update_non_pk_by update_unique_option_i32 = update_by_n(n), + delete_by delete_unique_option_i32 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + UniqueOptionI64 { + insert_or_panic insert_unique_option_i64, delete_all delete_all_unique_option_i64, + update_non_pk_by update_unique_option_i64 = update_by_n(n), + delete_by delete_unique_option_i64 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + UniqueOptionI128 { + insert_or_panic insert_unique_option_i128, delete_all delete_all_unique_option_i128, + update_non_pk_by update_unique_option_i128 = update_by_n(n), + delete_by delete_unique_option_i128 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + UniqueOptionI256 { + insert_or_panic insert_unique_option_i256, delete_all delete_all_unique_option_i256, + update_non_pk_by update_unique_option_i256 = update_by_n(n), + delete_by delete_unique_option_i256 = delete_by_n(n: Option), + } #[unique] n Option, data i32; + + + UniqueOptionBool { + insert_or_panic insert_unique_option_bool, delete_all delete_all_unique_option_bool, + update_non_pk_by update_unique_option_bool = update_by_b(b), + delete_by delete_unique_option_bool = delete_by_b(b: Option), + } #[unique] b Option, data i32; + + UniqueOptionString { + insert_or_panic insert_unique_option_string, delete_all delete_all_unique_option_string, + update_non_pk_by update_unique_option_string = update_by_s(s), + delete_by delete_unique_option_string = delete_by_s(s: Option), + } #[unique] s Option, data i32; + + UniqueOptionIdentity { + insert_or_panic insert_unique_option_identity, delete_all delete_all_unique_option_identity, + update_non_pk_by update_unique_option_identity = update_by_i(i), + delete_by delete_unique_option_identity = delete_by_i(i: Option), + } #[unique] i Option, data i32; + + UniqueOptionConnectionId { + insert_or_panic insert_unique_option_connection_id, delete_all delete_all_unique_option_connection_id, + update_non_pk_by update_unique_option_connection_id = update_by_a(a), + delete_by delete_unique_option_connection_id = delete_by_a(a: Option), + } #[unique] a Option, data i32; + + UniqueOptionUuid { + insert_or_panic insert_unique_option_uuid, delete_all delete_all_unique_option_uuid, + update_non_pk_by update_unique_option_uuid = update_by_u(u), + delete_by delete_unique_option_uuid = delete_by_u(u: Option), + } #[unique] u Option, data i32; +} + // Tables mapping a primary key to a boring i32 payload. // This allows us to test update and delete events. define_tables! { diff --git a/sdks/csharp/examples~/regression-tests/client/Program.cs b/sdks/csharp/examples~/regression-tests/client/Program.cs index 7f947cbc9d6..8ff95550767 100644 --- a/sdks/csharp/examples~/regression-tests/client/Program.cs +++ b/sdks/csharp/examples~/regression-tests/client/Program.cs @@ -50,6 +50,7 @@ void OnConnected(DbConnection conn, Identity identity, string authToken) .AddQuery(qb => qb.From.MyTable()) .AddQuery(qb => qb.From.NullStringNonnullable()) .AddQuery(qb => qb.From.NullStringNullable()) + .AddQuery(qb => qb.From.NullableUniqueLookup()) .AddQuery(qb => qb.From.MyLog()) .AddQuery(qb => qb.From.TestEvent()) .AddQuery(qb => qb.From.Admins()) @@ -195,6 +196,83 @@ int y ); }; + conn.Reducers.OnInsertNullableUniqueLookupRows += (ReducerEventContext ctx) => + { + Log.Info("Got InsertNullableUniqueLookupRows callback"); + waiting--; + Debug.Assert( + ctx.Event.Status is Status.Committed, + $"InsertNullableUniqueLookupRows should commit, got {ctx.Event.Status}" + ); + ValidateNullableUniqueLookupRows(ctx); + + Log.Debug("Calling DeleteNullableUniqueLookupByNumber(null)"); + waiting++; + conn.Reducers.DeleteNullableUniqueLookupByNumber(null); + + Log.Debug("Calling DeleteNullableUniqueLookupByString(null)"); + waiting++; + conn.Reducers.DeleteNullableUniqueLookupByString(null); + + Log.Debug("Calling DeleteNullableUniqueLookupByUuid(null)"); + waiting++; + conn.Reducers.DeleteNullableUniqueLookupByUuid(null); + }; + + conn.Reducers.OnDeleteNullableUniqueLookupByNumber += ( + ReducerEventContext ctx, + uint? optionalNumber + ) => + { + Log.Info("Got DeleteNullableUniqueLookupByNumber callback"); + waiting--; + Debug.Assert( + ctx.Event.Status is Status.Committed, + $"DeleteNullableUniqueLookupByNumber should commit, got {ctx.Event.Status}" + ); + Debug.Assert(optionalNumber is null, $"Expected null optionalNumber, got {optionalNumber}"); + Debug.Assert( + ctx.Db.NullableUniqueLookup.OptionalNumber.Find((uint?)null) is null, + "Expected OptionalNumber.Find(null) to be absent after delete" + ); + }; + + conn.Reducers.OnDeleteNullableUniqueLookupByString += ( + ReducerEventContext ctx, + string? optionalString + ) => + { + Log.Info("Got DeleteNullableUniqueLookupByString callback"); + waiting--; + Debug.Assert( + ctx.Event.Status is Status.Committed, + $"DeleteNullableUniqueLookupByString should commit, got {ctx.Event.Status}" + ); + Debug.Assert(optionalString is null, $"Expected null optionalString, got {optionalString}"); + Debug.Assert( + ctx.Db.NullableUniqueLookup.OptionalString.Find(null) is null, + "Expected OptionalString.Find(null) to be absent after delete" + ); + }; + + conn.Reducers.OnDeleteNullableUniqueLookupByUuid += ( + ReducerEventContext ctx, + Uuid? optionalUuid + ) => + { + Log.Info("Got DeleteNullableUniqueLookupByUuid callback"); + waiting--; + Debug.Assert( + ctx.Event.Status is Status.Committed, + $"DeleteNullableUniqueLookupByUuid should commit, got {ctx.Event.Status}" + ); + Debug.Assert(optionalUuid is null, $"Expected null optionalUuid, got {optionalUuid}"); + Debug.Assert( + ctx.Db.NullableUniqueLookup.OptionalUuid.Find(null) is null, + "Expected OptionalUuid.Find(null) to be absent after delete" + ); + }; + conn.Reducers.OnUpdateWhereTest += ( ReducerEventContext ctx, uint id, @@ -463,6 +541,35 @@ void ValidateNullableVecView( } } +void ValidateNullableUniqueLookupRows(IRemoteDbContext conn) +{ + Log.Debug("Checking nullable unique lookup indexes..."); + + var numberNull = conn.Db.NullableUniqueLookup.OptionalNumber.Find((uint?)null); + Debug.Assert(numberNull is not null, "Expected OptionalNumber.Find(null) to find row 1"); + Debug.Assert(numberNull.Id == 1, $"Expected OptionalNumber null row id 1, got {numberNull.Id}"); + + var numberValue = conn.Db.NullableUniqueLookup.OptionalNumber.Find(7); + Debug.Assert(numberValue is not null, "Expected OptionalNumber.Find(7) to find row 2"); + Debug.Assert(numberValue.Id == 2, $"Expected OptionalNumber 7 row id 2, got {numberValue.Id}"); + + var stringNull = conn.Db.NullableUniqueLookup.OptionalString.Find(null); + Debug.Assert(stringNull is not null, "Expected OptionalString.Find(null) to find row 2"); + Debug.Assert(stringNull.Id == 2, $"Expected OptionalString null row id 2, got {stringNull.Id}"); + + var stringValue = conn.Db.NullableUniqueLookup.OptionalString.Find("alpha"); + Debug.Assert(stringValue is not null, "Expected OptionalString.Find(\"alpha\") to find row 1"); + Debug.Assert(stringValue.Id == 1, $"Expected OptionalString alpha row id 1, got {stringValue.Id}"); + + var uuidNull = conn.Db.NullableUniqueLookup.OptionalUuid.Find(null); + Debug.Assert(uuidNull is not null, "Expected OptionalUuid.Find(null) to find row 3"); + Debug.Assert(uuidNull.Id == 3, $"Expected OptionalUuid null row id 3, got {uuidNull.Id}"); + + var uuidValue = conn.Db.NullableUniqueLookup.OptionalUuid.Find(Uuid.NIL); + Debug.Assert(uuidValue is not null, "Expected OptionalUuid.Find(Uuid.NIL) to find row 1"); + Debug.Assert(uuidValue.Id == 1, $"Expected OptionalUuid NIL row id 1, got {uuidValue.Id}"); +} + void ValidateReducerErrorDoesNotContainStackTrace(Exception exception) { Debug.Assert( @@ -1303,6 +1410,10 @@ void OnSubscriptionApplied(SubscriptionEventContext context) waiting++; context.Reducers.InsertNullStringIntoNullable(); + Log.Debug("Calling InsertNullableUniqueLookupRows"); + waiting++; + context.Reducers.InsertNullableUniqueLookupRows(); + Log.Debug("Calling EmitTestEvent"); waiting++; context.Reducers.EmitTestEvent(EXPECTED_TEST_EVENT_NAME, EXPECTED_TEST_EVENT_VALUE); diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByNumber.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByNumber.g.cs new file mode 100644 index 00000000000..44d4c6364dd --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByNumber.g.cs @@ -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. + +#nullable enable + +using System; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteReducers : RemoteBase + { + public delegate void DeleteNullableUniqueLookupByNumberHandler(ReducerEventContext ctx, uint? optionalNumber); + public event DeleteNullableUniqueLookupByNumberHandler? OnDeleteNullableUniqueLookupByNumber; + + public void DeleteNullableUniqueLookupByNumber(uint? optionalNumber) + { + conn.InternalCallReducer(new Reducer.DeleteNullableUniqueLookupByNumber(optionalNumber)); + } + + public bool InvokeDeleteNullableUniqueLookupByNumber(ReducerEventContext ctx, Reducer.DeleteNullableUniqueLookupByNumber args) + { + if (OnDeleteNullableUniqueLookupByNumber == null) + { + if (InternalOnUnhandledReducerError != null) + { + switch (ctx.Event.Status) + { + case Status.Failed(var reason): InternalOnUnhandledReducerError(ctx, new Exception(reason)); break; + case Status.OutOfEnergy(var _): InternalOnUnhandledReducerError(ctx, new Exception("out of energy")); break; + } + } + return false; + } + OnDeleteNullableUniqueLookupByNumber( + ctx, + args.OptionalNumber + ); + return true; + } + } + + public abstract partial class Reducer + { + [SpacetimeDB.Type] + [DataContract] + public sealed partial class DeleteNullableUniqueLookupByNumber : Reducer, IReducerArgs + { + [DataMember(Name = "optional_number")] + public uint? OptionalNumber; + + public DeleteNullableUniqueLookupByNumber(uint? OptionalNumber) + { + this.OptionalNumber = OptionalNumber; + } + + public DeleteNullableUniqueLookupByNumber() + { + } + + string IReducerArgs.ReducerName => "delete_nullable_unique_lookup_by_number"; + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByString.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByString.g.cs new file mode 100644 index 00000000000..b972eb25805 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByString.g.cs @@ -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. + +#nullable enable + +using System; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteReducers : RemoteBase + { + public delegate void DeleteNullableUniqueLookupByStringHandler(ReducerEventContext ctx, string? optionalString); + public event DeleteNullableUniqueLookupByStringHandler? OnDeleteNullableUniqueLookupByString; + + public void DeleteNullableUniqueLookupByString(string? optionalString) + { + conn.InternalCallReducer(new Reducer.DeleteNullableUniqueLookupByString(optionalString)); + } + + public bool InvokeDeleteNullableUniqueLookupByString(ReducerEventContext ctx, Reducer.DeleteNullableUniqueLookupByString args) + { + if (OnDeleteNullableUniqueLookupByString == null) + { + if (InternalOnUnhandledReducerError != null) + { + switch (ctx.Event.Status) + { + case Status.Failed(var reason): InternalOnUnhandledReducerError(ctx, new Exception(reason)); break; + case Status.OutOfEnergy(var _): InternalOnUnhandledReducerError(ctx, new Exception("out of energy")); break; + } + } + return false; + } + OnDeleteNullableUniqueLookupByString( + ctx, + args.OptionalString + ); + return true; + } + } + + public abstract partial class Reducer + { + [SpacetimeDB.Type] + [DataContract] + public sealed partial class DeleteNullableUniqueLookupByString : Reducer, IReducerArgs + { + [DataMember(Name = "optional_string")] + public string? OptionalString; + + public DeleteNullableUniqueLookupByString(string? OptionalString) + { + this.OptionalString = OptionalString; + } + + public DeleteNullableUniqueLookupByString() + { + } + + string IReducerArgs.ReducerName => "delete_nullable_unique_lookup_by_string"; + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByUuid.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByUuid.g.cs new file mode 100644 index 00000000000..916d0c99643 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByUuid.g.cs @@ -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. + +#nullable enable + +using System; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteReducers : RemoteBase + { + public delegate void DeleteNullableUniqueLookupByUuidHandler(ReducerEventContext ctx, SpacetimeDB.Uuid? optionalUuid); + public event DeleteNullableUniqueLookupByUuidHandler? OnDeleteNullableUniqueLookupByUuid; + + public void DeleteNullableUniqueLookupByUuid(SpacetimeDB.Uuid? optionalUuid) + { + conn.InternalCallReducer(new Reducer.DeleteNullableUniqueLookupByUuid(optionalUuid)); + } + + public bool InvokeDeleteNullableUniqueLookupByUuid(ReducerEventContext ctx, Reducer.DeleteNullableUniqueLookupByUuid args) + { + if (OnDeleteNullableUniqueLookupByUuid == null) + { + if (InternalOnUnhandledReducerError != null) + { + switch (ctx.Event.Status) + { + case Status.Failed(var reason): InternalOnUnhandledReducerError(ctx, new Exception(reason)); break; + case Status.OutOfEnergy(var _): InternalOnUnhandledReducerError(ctx, new Exception("out of energy")); break; + } + } + return false; + } + OnDeleteNullableUniqueLookupByUuid( + ctx, + args.OptionalUuid + ); + return true; + } + } + + public abstract partial class Reducer + { + [SpacetimeDB.Type] + [DataContract] + public sealed partial class DeleteNullableUniqueLookupByUuid : Reducer, IReducerArgs + { + [DataMember(Name = "optional_uuid")] + public SpacetimeDB.Uuid? OptionalUuid; + + public DeleteNullableUniqueLookupByUuid(SpacetimeDB.Uuid? OptionalUuid) + { + this.OptionalUuid = OptionalUuid; + } + + public DeleteNullableUniqueLookupByUuid() + { + } + + string IReducerArgs.ReducerName => "delete_nullable_unique_lookup_by_uuid"; + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/InsertNullableUniqueLookupRows.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/InsertNullableUniqueLookupRows.g.cs new file mode 100644 index 00000000000..680bf18f902 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/InsertNullableUniqueLookupRows.g.cs @@ -0,0 +1,53 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#nullable enable + +using System; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteReducers : RemoteBase + { + public delegate void InsertNullableUniqueLookupRowsHandler(ReducerEventContext ctx); + public event InsertNullableUniqueLookupRowsHandler? OnInsertNullableUniqueLookupRows; + + public void InsertNullableUniqueLookupRows() + { + conn.InternalCallReducer(new Reducer.InsertNullableUniqueLookupRows()); + } + + public bool InvokeInsertNullableUniqueLookupRows(ReducerEventContext ctx, Reducer.InsertNullableUniqueLookupRows args) + { + if (OnInsertNullableUniqueLookupRows == null) + { + if (InternalOnUnhandledReducerError != null) + { + switch (ctx.Event.Status) + { + case Status.Failed(var reason): InternalOnUnhandledReducerError(ctx, new Exception(reason)); break; + case Status.OutOfEnergy(var _): InternalOnUnhandledReducerError(ctx, new Exception("out of energy")); break; + } + } + return false; + } + OnInsertNullableUniqueLookupRows( + ctx + ); + return true; + } + } + + public abstract partial class Reducer + { + [SpacetimeDB.Type] + [DataContract] + public sealed partial class InsertNullableUniqueLookupRows : Reducer, IReducerArgs + { + string IReducerArgs.ReducerName => "insert_nullable_unique_lookup_rows"; + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs index 0fa3dd38aa7..88521597075 100644 --- a/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs @@ -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.4.1 (commit ed95086da83809e1e621aae0066b0970a4130a3e). +// This was generated using spacetimedb cli version 2.7.0 (commit 5f2a3f87a144481aa88567616b3352d78d0be82e). #nullable enable @@ -47,6 +47,7 @@ public RemoteTables(DbConnection conn) AddTable(MyTable = new(conn)); AddTable(NullStringNonnullable = new(conn)); AddTable(NullStringNullable = new(conn)); + AddTable(NullableUniqueLookup = new(conn)); AddTable(NullableVec = new(conn)); AddTable(NullableVecView = new(conn)); AddTable(Player = new(conn)); @@ -589,6 +590,7 @@ public sealed class QueryBuilder new QueryBuilder().From.MyTable().ToSql(), new QueryBuilder().From.NullStringNonnullable().ToSql(), new QueryBuilder().From.NullStringNullable().ToSql(), + new QueryBuilder().From.NullableUniqueLookup().ToSql(), new QueryBuilder().From.NullableVec().ToSql(), new QueryBuilder().From.NullableVecView().ToSql(), new QueryBuilder().From.Player().ToSql(), @@ -641,6 +643,7 @@ public sealed class From public global::SpacetimeDB.Table MyTable() => new("my_table", new MyTableCols("my_table"), new MyTableIxCols("my_table")); public global::SpacetimeDB.Table NullStringNonnullable() => new("null_string_nonnullable", new NullStringNonnullableCols("null_string_nonnullable"), new NullStringNonnullableIxCols("null_string_nonnullable")); public global::SpacetimeDB.Table NullStringNullable() => new("null_string_nullable", new NullStringNullableCols("null_string_nullable"), new NullStringNullableIxCols("null_string_nullable")); + public global::SpacetimeDB.Table NullableUniqueLookup() => new("nullable_unique_lookup", new NullableUniqueLookupCols("nullable_unique_lookup"), new NullableUniqueLookupIxCols("nullable_unique_lookup")); public global::SpacetimeDB.Table NullableVec() => new("nullable_vec", new NullableVecCols("nullable_vec"), new NullableVecIxCols("nullable_vec")); public global::SpacetimeDB.Table NullableVecView() => new("nullable_vec_view", new NullableVecViewCols("nullable_vec_view"), new NullableVecViewIxCols("nullable_vec_view")); public global::SpacetimeDB.Table Player() => new("player", new PlayerCols("player"), new PlayerIxCols("player")); @@ -753,8 +756,12 @@ protected override bool Dispatch(IReducerEventContext context, Reducer reducer) Reducer.AddEqualityPerson args => Reducers.InvokeAddEqualityPerson(eventContext, args), Reducer.AddEqualityProduct args => Reducers.InvokeAddEqualityProduct(eventContext, args), Reducer.Delete args => Reducers.InvokeDelete(eventContext, args), + Reducer.DeleteNullableUniqueLookupByNumber args => Reducers.InvokeDeleteNullableUniqueLookupByNumber(eventContext, args), + Reducer.DeleteNullableUniqueLookupByString args => Reducers.InvokeDeleteNullableUniqueLookupByString(eventContext, args), + Reducer.DeleteNullableUniqueLookupByUuid args => Reducers.InvokeDeleteNullableUniqueLookupByUuid(eventContext, args), Reducer.EmitTestEvent args => Reducers.InvokeEmitTestEvent(eventContext, args), Reducer.InsertEmptyStringIntoNonNullable args => Reducers.InvokeInsertEmptyStringIntoNonNullable(eventContext, args), + Reducer.InsertNullableUniqueLookupRows args => Reducers.InvokeInsertNullableUniqueLookupRows(eventContext, args), Reducer.InsertNullStringIntoNonNullable args => Reducers.InvokeInsertNullStringIntoNonNullable(eventContext, args), Reducer.InsertNullStringIntoNullable args => Reducers.InvokeInsertNullStringIntoNullable(eventContext, args), Reducer.InsertResult args => Reducers.InvokeInsertResult(eventContext, args), diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Tables/NullableUniqueLookup.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Tables/NullableUniqueLookup.g.cs new file mode 100644 index 00000000000..29c4f329ae2 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Tables/NullableUniqueLookup.g.cs @@ -0,0 +1,101 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#nullable enable + +using System; +using SpacetimeDB.BSATN; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteTables + { + public sealed class NullableUniqueLookupHandle : RemoteTableHandle + { + protected override string RemoteTableName => "nullable_unique_lookup"; + + public sealed class IdUniqueIndex : UniqueIndexBase + { + protected override uint GetKey(NullableUniqueLookup row) => row.Id; + + public IdUniqueIndex(NullableUniqueLookupHandle table) : base(table) { } + } + + public readonly IdUniqueIndex Id; + + public sealed class OptionalNumberUniqueIndex : NullableUniqueIndexBase + { + protected override uint? GetKey(NullableUniqueLookup row) => row.OptionalNumber; + + public OptionalNumberUniqueIndex(NullableUniqueLookupHandle table) : base(table) { } + } + + public readonly OptionalNumberUniqueIndex OptionalNumber; + + public sealed class OptionalStringUniqueIndex : NullableUniqueIndexBase + { + protected override string? GetKey(NullableUniqueLookup row) => row.OptionalString; + + public OptionalStringUniqueIndex(NullableUniqueLookupHandle table) : base(table) { } + } + + public readonly OptionalStringUniqueIndex OptionalString; + + public sealed class OptionalUuidUniqueIndex : NullableUniqueIndexBase + { + protected override SpacetimeDB.Uuid? GetKey(NullableUniqueLookup row) => row.OptionalUuid; + + public OptionalUuidUniqueIndex(NullableUniqueLookupHandle table) : base(table) { } + } + + public readonly OptionalUuidUniqueIndex OptionalUuid; + + internal NullableUniqueLookupHandle(DbConnection conn) : base(conn) + { + Id = new(this); + OptionalNumber = new(this); + OptionalString = new(this); + OptionalUuid = new(this); + } + + protected override object GetPrimaryKey(NullableUniqueLookup row) => row.Id; + } + + public readonly NullableUniqueLookupHandle NullableUniqueLookup; + } + + public sealed class NullableUniqueLookupCols + { + public global::SpacetimeDB.Col Id { get; } + public global::SpacetimeDB.Col OptionalNumber { get; } + public global::SpacetimeDB.Col OptionalString { get; } + public global::SpacetimeDB.Col OptionalUuid { get; } + + public NullableUniqueLookupCols(string tableName) + { + Id = new global::SpacetimeDB.Col(tableName, "id"); + OptionalNumber = new global::SpacetimeDB.Col(tableName, "optional_number"); + OptionalString = new global::SpacetimeDB.Col(tableName, "optional_string"); + OptionalUuid = new global::SpacetimeDB.Col(tableName, "optional_uuid"); + } + } + + public sealed class NullableUniqueLookupIxCols + { + public global::SpacetimeDB.IxCol Id { get; } + public global::SpacetimeDB.IxCol OptionalNumber { get; } + public global::SpacetimeDB.IxCol OptionalString { get; } + public global::SpacetimeDB.IxCol OptionalUuid { get; } + + public NullableUniqueLookupIxCols(string tableName) + { + Id = new global::SpacetimeDB.IxCol(tableName, "id"); + OptionalNumber = new global::SpacetimeDB.IxCol(tableName, "optional_number"); + OptionalString = new global::SpacetimeDB.IxCol(tableName, "optional_string"); + OptionalUuid = new global::SpacetimeDB.IxCol(tableName, "optional_uuid"); + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Types/NullableUniqueLookup.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Types/NullableUniqueLookup.g.cs new file mode 100644 index 00000000000..7182b19ff57 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Types/NullableUniqueLookup.g.cs @@ -0,0 +1,42 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#nullable enable + +using System; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + [SpacetimeDB.Type] + [DataContract] + public sealed partial class NullableUniqueLookup + { + [DataMember(Name = "id")] + public uint Id; + [DataMember(Name = "optional_number")] + public uint? OptionalNumber; + [DataMember(Name = "optional_string")] + public string? OptionalString; + [DataMember(Name = "optional_uuid")] + public SpacetimeDB.Uuid? OptionalUuid; + + public NullableUniqueLookup( + uint Id, + uint? OptionalNumber, + string? OptionalString, + SpacetimeDB.Uuid? OptionalUuid + ) + { + this.Id = Id; + this.OptionalNumber = OptionalNumber; + this.OptionalString = OptionalString; + this.OptionalUuid = OptionalUuid; + } + + public NullableUniqueLookup() + { + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/procedure-client/module_bindings/SpacetimeDBClient.g.cs b/sdks/csharp/examples~/regression-tests/procedure-client/module_bindings/SpacetimeDBClient.g.cs index 948b4e405d7..91a4f49cb17 100644 --- a/sdks/csharp/examples~/regression-tests/procedure-client/module_bindings/SpacetimeDBClient.g.cs +++ b/sdks/csharp/examples~/regression-tests/procedure-client/module_bindings/SpacetimeDBClient.g.cs @@ -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.0.4 (commit dfc726be29516b8cdecc651f5c9705026a624a04). +// This was generated using spacetimedb cli version 2.7.0 (commit 5f2a3f87a144481aa88567616b3352d78d0be82e). #nullable enable diff --git a/sdks/csharp/examples~/regression-tests/republishing/client/module_bindings/SpacetimeDBClient.g.cs b/sdks/csharp/examples~/regression-tests/republishing/client/module_bindings/SpacetimeDBClient.g.cs index ba9311b5d45..f89d47117f0 100644 --- a/sdks/csharp/examples~/regression-tests/republishing/client/module_bindings/SpacetimeDBClient.g.cs +++ b/sdks/csharp/examples~/regression-tests/republishing/client/module_bindings/SpacetimeDBClient.g.cs @@ -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.0.0 (commit 4cce69765507c1815979d39572b4a52864f5c3d2). +// This was generated using spacetimedb cli version 2.7.0 (commit 5f2a3f87a144481aa88567616b3352d78d0be82e). #nullable enable diff --git a/sdks/csharp/examples~/regression-tests/server/Lib.cs b/sdks/csharp/examples~/regression-tests/server/Lib.cs index e3391b710ff..2ec11174a4c 100644 --- a/sdks/csharp/examples~/regression-tests/server/Lib.cs +++ b/sdks/csharp/examples~/regression-tests/server/Lib.cs @@ -172,6 +172,22 @@ public partial struct NullStringNullable public string? Name; } + [SpacetimeDB.Table(Accessor = "nullable_unique_lookup", Public = true)] + public partial struct NullableUniqueLookup + { + [SpacetimeDB.PrimaryKey] + public uint Id; + + [SpacetimeDB.Unique] + public uint? OptionalNumber; + + [SpacetimeDB.Unique] + public string? OptionalString; + + [SpacetimeDB.Unique] + public Uuid? OptionalUuid; + } + [SpacetimeDB.Table(Accessor = "view_pk_player", Public = true)] public partial struct ViewPkPlayer { @@ -598,6 +614,56 @@ public static void InsertNullStringIntoNullable(ReducerContext ctx) ctx.Db.null_string_nullable.Insert(new NullStringNullable { Name = null }); } + [SpacetimeDB.Reducer] + public static void InsertNullableUniqueLookupRows(ReducerContext ctx) + { + ctx.Db.nullable_unique_lookup.Insert( + new NullableUniqueLookup + { + Id = 1, + OptionalNumber = null, + OptionalString = "alpha", + OptionalUuid = Uuid.NIL, + } + ); + ctx.Db.nullable_unique_lookup.Insert( + new NullableUniqueLookup + { + Id = 2, + OptionalNumber = 7, + OptionalString = null, + OptionalUuid = Uuid.MAX, + } + ); + ctx.Db.nullable_unique_lookup.Insert( + new NullableUniqueLookup + { + Id = 3, + OptionalNumber = 8, + OptionalString = "beta", + OptionalUuid = null, + } + ); + } + + [SpacetimeDB.Reducer] + public static void DeleteNullableUniqueLookupByNumber(ReducerContext ctx, uint? optionalNumber) + { + ctx.Db.nullable_unique_lookup.OptionalNumber.Delete(optionalNumber); + } + + [SpacetimeDB.Reducer] + public static void DeleteNullableUniqueLookupByString(ReducerContext ctx, string? optionalString) + { + ctx.Db.nullable_unique_lookup.OptionalString.Delete(optionalString); + } + + [SpacetimeDB.Reducer] + public static void DeleteNullableUniqueLookupByUuid(ReducerContext ctx, Uuid? optionalUuid) + { + ctx.Db.nullable_unique_lookup.OptionalUuid.Delete(optionalUuid); + } + [SpacetimeDB.Reducer] public static void InsertWhereTest(ReducerContext ctx, uint id, uint value, string name) { diff --git a/sdks/csharp/src/Table.cs b/sdks/csharp/src/Table.cs index 620d99fffd1..8323c85fba7 100644 --- a/sdks/csharp/src/Table.cs +++ b/sdks/csharp/src/Table.cs @@ -154,6 +154,76 @@ public IEnumerable Filter(Column value) => cache.TryGetValue(value, out var rows) ? rows : Enumerable.Empty(); } + public abstract class NullableIndexBase + { + protected readonly struct IndexKey : IEquatable + { + private static readonly EqualityComparer Comparer = EqualityComparer.Default; + + private readonly Column value; + + public IndexKey(Column value) + { + this.value = value; + } + + public bool Equals(IndexKey other) => Comparer.Equals(value, other.value); + + public override bool Equals(object? obj) => obj is IndexKey other && Equals(other); + + public override int GetHashCode() => Comparer.GetHashCode(value!); + } + + protected abstract Column GetKey(Row row); + } + + public abstract class NullableUniqueIndexBase : NullableIndexBase + { + private readonly Dictionary cache = new(); + + public NullableUniqueIndexBase(RemoteTableHandleBase table) + { + table.OnInternalInsert += row => cache.Add(new IndexKey(GetKey(row)), row); + table.OnInternalDelete += row => cache.Remove(new IndexKey(GetKey(row))); + } + + public Row? Find(Column value) => cache.TryGetValue(new IndexKey(value), out var row) ? row : null; + } + + public abstract class NullableBTreeIndexBase : NullableIndexBase + { + // TODO: change to SortedDictionary when adding support for range queries. + private readonly Dictionary> cache = new(); + + public NullableBTreeIndexBase(RemoteTableHandleBase table) + { + table.OnInternalInsert += row => + { + var key = new IndexKey(GetKey(row)); + if (!cache.TryGetValue(key, out var rows)) + { + rows = new(); + cache.Add(key, rows); + } + rows.Add(row); + }; + + table.OnInternalDelete += row => + { + var key = new IndexKey(GetKey(row)); + var keyCache = cache[key]; + keyCache.Remove(row); + if (keyCache.Count == 0) + { + cache.Remove(key); + } + }; + } + + public IEnumerable Filter(Column value) => + cache.TryGetValue(new IndexKey(value), out var rows) ? rows : Enumerable.Empty(); + } + /// /// Represents a parsed update to a table, storing the changes as a multi-dictionary delta /// mapping primary keys to their corresponding row updates. 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/delete_all_option_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_option_i_32_reducer.rs new file mode 100644 index 00000000000..5bef2b26a95 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_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 DeleteAllOptionI32Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteAllOptionI32Args) -> Self { + Self::DeleteAllOptionI32 { n: args.n } + } +} + +impl __sdk::InModule for DeleteAllOptionI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_option_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +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 [`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 `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 delete_all_option_i_32_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_option_i_32 for super::RemoteReducers { + fn delete_all_option_i_32_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .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_option_bool_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_bool_reducer.rs new file mode 100644 index 00000000000..31e811cd45b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionBoolArgs { + pub b: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionBoolArgs) -> Self { + Self::DeleteAllUniqueOptionBool { + b: args.b, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionBoolArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_bool`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_bool { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_bool:delete_all_unique_option_bool_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_bool(&self, b: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_bool_then(b, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_bool_then( + &self, + b: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_bool for super::RemoteReducers { + fn delete_all_unique_option_bool_then( + &self, + b: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionBoolArgs { b, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_connection_id_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_connection_id_reducer.rs new file mode 100644 index 00000000000..9be4a626b4f --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionConnectionIdArgs { + pub a: Option<__sdk::ConnectionId>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionConnectionIdArgs) -> Self { + Self::DeleteAllUniqueOptionConnectionId { + a: args.a, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionConnectionIdArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_connection_id`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_connection_id { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_connection_id:delete_all_unique_option_connection_id_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_connection_id(&self, a: Option<__sdk::ConnectionId>, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_connection_id_then(a, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_connection_id_then( + &self, + a: Option<__sdk::ConnectionId>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_connection_id for super::RemoteReducers { + fn delete_all_unique_option_connection_id_then( + &self, + a: Option<__sdk::ConnectionId>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionConnectionIdArgs { a, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_128_reducer.rs new file mode 100644 index 00000000000..b69f82b85bb --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionI128Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionI128Args) -> Self { + Self::DeleteAllUniqueOptionI128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionI128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_i_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_i_128 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_128:delete_all_unique_option_i_128_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_i_128(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_i_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_i_128 for super::RemoteReducers { + fn delete_all_unique_option_i_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionI128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_16_reducer.rs new file mode 100644 index 00000000000..2d5f3bfcb37 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionI16Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionI16Args) -> Self { + Self::DeleteAllUniqueOptionI16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionI16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_i_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_i_16 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_16:delete_all_unique_option_i_16_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_i_16(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_i_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_i_16 for super::RemoteReducers { + fn delete_all_unique_option_i_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionI16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_256_reducer.rs new file mode 100644 index 00000000000..eba9aea4fc7 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionI256Args { + pub n: Option<__sats::i256>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionI256Args) -> Self { + Self::DeleteAllUniqueOptionI256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionI256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_i_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_i_256 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_256:delete_all_unique_option_i_256_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_i_256(&self, n: Option<__sats::i256>, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_i_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_256_then( + &self, + n: Option<__sats::i256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_i_256 for super::RemoteReducers { + fn delete_all_unique_option_i_256_then( + &self, + n: Option<__sats::i256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionI256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_32_reducer.rs new file mode 100644 index 00000000000..db7b95e9cac --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionI32Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionI32Args) -> Self { + Self::DeleteAllUniqueOptionI32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_i_32 { + /// Request that the remote module invoke the reducer `delete_all_unique_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_unique_option_i_32:delete_all_unique_option_i_32_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_i_32(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_i_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_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_unique_option_i_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_i_32 for super::RemoteReducers { + fn delete_all_unique_option_i_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionI32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_64_reducer.rs new file mode 100644 index 00000000000..e19c04e2259 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionI64Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionI64Args) -> Self { + Self::DeleteAllUniqueOptionI64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionI64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_i_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_i_64 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_64:delete_all_unique_option_i_64_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_i_64(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_i_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_i_64 for super::RemoteReducers { + fn delete_all_unique_option_i_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionI64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_i_8_reducer.rs new file mode 100644 index 00000000000..fd3a3a9d6f6 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionI8Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionI8Args) -> Self { + Self::DeleteAllUniqueOptionI8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionI8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_i_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_i_8 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_8:delete_all_unique_option_i_8_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_i_8(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_i_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_i_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_i_8 for super::RemoteReducers { + fn delete_all_unique_option_i_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionI8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_identity_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_identity_reducer.rs new file mode 100644 index 00000000000..622252c6494 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionIdentityArgs { + pub i: Option<__sdk::Identity>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionIdentityArgs) -> Self { + Self::DeleteAllUniqueOptionIdentity { + i: args.i, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionIdentityArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_identity`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_identity { + /// Request that the remote module invoke the reducer `delete_all_unique_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_unique_option_identity:delete_all_unique_option_identity_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_identity(&self, i: Option<__sdk::Identity>, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_identity_then(i, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_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_unique_option_identity_then( + &self, + i: Option<__sdk::Identity>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_identity for super::RemoteReducers { + fn delete_all_unique_option_identity_then( + &self, + i: Option<__sdk::Identity>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionIdentityArgs { i, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_string_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_string_reducer.rs new file mode 100644 index 00000000000..11622e97864 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionStringArgs { + pub s: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionStringArgs) -> Self { + Self::DeleteAllUniqueOptionString { + s: args.s, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionStringArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_string`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_string { + /// Request that the remote module invoke the reducer `delete_all_unique_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_unique_option_string:delete_all_unique_option_string_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_string(&self, s: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_string_then(s, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_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_unique_option_string_then( + &self, + s: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_string for super::RemoteReducers { + fn delete_all_unique_option_string_then( + &self, + s: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionStringArgs { s, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_128_reducer.rs new file mode 100644 index 00000000000..550438be8b6 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionU128Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionU128Args) -> Self { + Self::DeleteAllUniqueOptionU128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionU128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_u_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_u_128 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_128:delete_all_unique_option_u_128_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_u_128(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_u_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_u_128 for super::RemoteReducers { + fn delete_all_unique_option_u_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionU128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_16_reducer.rs new file mode 100644 index 00000000000..a4e017ac68a --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionU16Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionU16Args) -> Self { + Self::DeleteAllUniqueOptionU16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionU16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_u_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_u_16 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_16:delete_all_unique_option_u_16_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_u_16(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_u_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_u_16 for super::RemoteReducers { + fn delete_all_unique_option_u_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionU16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_256_reducer.rs new file mode 100644 index 00000000000..9a95cc76d39 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionU256Args { + pub n: Option<__sats::u256>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionU256Args) -> Self { + Self::DeleteAllUniqueOptionU256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionU256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_u_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_u_256 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_256:delete_all_unique_option_u_256_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_u_256(&self, n: Option<__sats::u256>, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_u_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_256_then( + &self, + n: Option<__sats::u256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_u_256 for super::RemoteReducers { + fn delete_all_unique_option_u_256_then( + &self, + n: Option<__sats::u256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionU256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_32_reducer.rs new file mode 100644 index 00000000000..cee48109563 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionU32Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionU32Args) -> Self { + Self::DeleteAllUniqueOptionU32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionU32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_u_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_u_32 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_32:delete_all_unique_option_u_32_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_u_32(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_u_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_u_32 for super::RemoteReducers { + fn delete_all_unique_option_u_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionU32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_64_reducer.rs new file mode 100644 index 00000000000..6999b431efb --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionU64Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionU64Args) -> Self { + Self::DeleteAllUniqueOptionU64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionU64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_u_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_u_64 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_64:delete_all_unique_option_u_64_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_u_64(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_u_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_u_64 for super::RemoteReducers { + fn delete_all_unique_option_u_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionU64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_u_8_reducer.rs new file mode 100644 index 00000000000..c48e307494a --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionU8Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionU8Args) -> Self { + Self::DeleteAllUniqueOptionU8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionU8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_u_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_u_8 { + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_8:delete_all_unique_option_u_8_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_u_8(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_u_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_option_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_option_u_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_u_8 for super::RemoteReducers { + fn delete_all_unique_option_u_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionU8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_uuid_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_uuid_reducer.rs new file mode 100644 index 00000000000..fd9fab2ea6a --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_all_unique_option_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 DeleteAllUniqueOptionUuidArgs { + pub u: Option<__sdk::Uuid>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: DeleteAllUniqueOptionUuidArgs) -> Self { + Self::DeleteAllUniqueOptionUuid { + u: args.u, + data: args.data, + } + } +} + +impl __sdk::InModule for DeleteAllUniqueOptionUuidArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_all_unique_option_uuid`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_all_unique_option_uuid { + /// Request that the remote module invoke the reducer `delete_all_unique_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_unique_option_uuid:delete_all_unique_option_uuid_then`] to run a callback after the reducer completes. + fn delete_all_unique_option_uuid(&self, u: Option<__sdk::Uuid>, data: i32) -> __sdk::Result<()> { + self.delete_all_unique_option_uuid_then(u, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_all_unique_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_unique_option_uuid_then( + &self, + u: Option<__sdk::Uuid>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_all_unique_option_uuid for super::RemoteReducers { + fn delete_all_unique_option_uuid_then( + &self, + u: Option<__sdk::Uuid>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteAllUniqueOptionUuidArgs { u, 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/delete_unique_option_bool_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_bool_reducer.rs new file mode 100644 index 00000000000..440cb45dc23 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionBoolArgs { + pub b: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionBoolArgs) -> Self { + Self::DeleteUniqueOptionBool { b: args.b } + } +} + +impl __sdk::InModule for DeleteUniqueOptionBoolArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_bool`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_bool { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_bool:delete_unique_option_bool_then`] to run a callback after the reducer completes. + fn delete_unique_option_bool(&self, b: Option) -> __sdk::Result<()> { + self.delete_unique_option_bool_then(b, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_bool_then( + &self, + b: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_bool for super::RemoteReducers { + fn delete_unique_option_bool_then( + &self, + b: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionBoolArgs { b }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_connection_id_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_connection_id_reducer.rs new file mode 100644 index 00000000000..1d1900ea05c --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_connection_id_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 DeleteUniqueOptionConnectionIdArgs { + pub a: Option<__sdk::ConnectionId>, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionConnectionIdArgs) -> Self { + Self::DeleteUniqueOptionConnectionId { a: args.a } + } +} + +impl __sdk::InModule for DeleteUniqueOptionConnectionIdArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_connection_id`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_connection_id { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_connection_id:delete_unique_option_connection_id_then`] to run a callback after the reducer completes. + fn delete_unique_option_connection_id(&self, a: Option<__sdk::ConnectionId>) -> __sdk::Result<()> { + self.delete_unique_option_connection_id_then(a, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_connection_id_then( + &self, + a: Option<__sdk::ConnectionId>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_connection_id for super::RemoteReducers { + fn delete_unique_option_connection_id_then( + &self, + a: Option<__sdk::ConnectionId>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionConnectionIdArgs { a }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_128_reducer.rs new file mode 100644 index 00000000000..423c5c2cc4b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionI128Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionI128Args) -> Self { + Self::DeleteUniqueOptionI128 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionI128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_i_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_i_128 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_128:delete_unique_option_i_128_then`] to run a callback after the reducer completes. + fn delete_unique_option_i_128(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_i_128_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_128_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_i_128 for super::RemoteReducers { + fn delete_unique_option_i_128_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionI128Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_16_reducer.rs new file mode 100644 index 00000000000..cd33fc556c7 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionI16Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionI16Args) -> Self { + Self::DeleteUniqueOptionI16 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionI16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_i_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_i_16 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_16:delete_unique_option_i_16_then`] to run a callback after the reducer completes. + fn delete_unique_option_i_16(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_i_16_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_16_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_i_16 for super::RemoteReducers { + fn delete_unique_option_i_16_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionI16Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_256_reducer.rs new file mode 100644 index 00000000000..d981bdd9439 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionI256Args { + pub n: Option<__sats::i256>, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionI256Args) -> Self { + Self::DeleteUniqueOptionI256 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionI256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_i_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_i_256 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_256:delete_unique_option_i_256_then`] to run a callback after the reducer completes. + fn delete_unique_option_i_256(&self, n: Option<__sats::i256>) -> __sdk::Result<()> { + self.delete_unique_option_i_256_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_256_then( + &self, + n: Option<__sats::i256>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_i_256 for super::RemoteReducers { + fn delete_unique_option_i_256_then( + &self, + n: Option<__sats::i256>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionI256Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_32_reducer.rs new file mode 100644 index 00000000000..b4264cdabf1 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_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 DeleteUniqueOptionI32Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionI32Args) -> Self { + Self::DeleteUniqueOptionI32 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_i_32 { + /// Request that the remote module invoke the reducer `delete_unique_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_unique_option_i_32:delete_unique_option_i_32_then`] to run a callback after the reducer completes. + fn delete_unique_option_i_32(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_i_32_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_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_unique_option_i_32_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_i_32 for super::RemoteReducers { + fn delete_unique_option_i_32_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionI32Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_64_reducer.rs new file mode 100644 index 00000000000..6ed39d9e456 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionI64Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionI64Args) -> Self { + Self::DeleteUniqueOptionI64 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionI64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_i_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_i_64 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_64:delete_unique_option_i_64_then`] to run a callback after the reducer completes. + fn delete_unique_option_i_64(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_i_64_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_64_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_i_64 for super::RemoteReducers { + fn delete_unique_option_i_64_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionI64Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_i_8_reducer.rs new file mode 100644 index 00000000000..8cf44ea4d22 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionI8Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionI8Args) -> Self { + Self::DeleteUniqueOptionI8 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionI8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_i_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_i_8 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_8:delete_unique_option_i_8_then`] to run a callback after the reducer completes. + fn delete_unique_option_i_8(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_i_8_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_i_8_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_i_8 for super::RemoteReducers { + fn delete_unique_option_i_8_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionI8Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_identity_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_identity_reducer.rs new file mode 100644 index 00000000000..2b7c23e3c42 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_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 DeleteUniqueOptionIdentityArgs { + pub i: Option<__sdk::Identity>, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionIdentityArgs) -> Self { + Self::DeleteUniqueOptionIdentity { i: args.i } + } +} + +impl __sdk::InModule for DeleteUniqueOptionIdentityArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_identity`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_identity { + /// Request that the remote module invoke the reducer `delete_unique_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_unique_option_identity:delete_unique_option_identity_then`] to run a callback after the reducer completes. + fn delete_unique_option_identity(&self, i: Option<__sdk::Identity>) -> __sdk::Result<()> { + self.delete_unique_option_identity_then(i, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_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_unique_option_identity_then( + &self, + i: Option<__sdk::Identity>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_identity for super::RemoteReducers { + fn delete_unique_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(DeleteUniqueOptionIdentityArgs { i }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_string_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_string_reducer.rs new file mode 100644 index 00000000000..d4c3878072b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_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 DeleteUniqueOptionStringArgs { + pub s: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionStringArgs) -> Self { + Self::DeleteUniqueOptionString { s: args.s } + } +} + +impl __sdk::InModule for DeleteUniqueOptionStringArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_string`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_string { + /// Request that the remote module invoke the reducer `delete_unique_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_unique_option_string:delete_unique_option_string_then`] to run a callback after the reducer completes. + fn delete_unique_option_string(&self, s: Option) -> __sdk::Result<()> { + self.delete_unique_option_string_then(s, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_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_unique_option_string_then( + &self, + s: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_string for super::RemoteReducers { + fn delete_unique_option_string_then( + &self, + s: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionStringArgs { s }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_128_reducer.rs new file mode 100644 index 00000000000..7b405eb1953 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionU128Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionU128Args) -> Self { + Self::DeleteUniqueOptionU128 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionU128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_u_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_u_128 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_128:delete_unique_option_u_128_then`] to run a callback after the reducer completes. + fn delete_unique_option_u_128(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_u_128_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_128_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_u_128 for super::RemoteReducers { + fn delete_unique_option_u_128_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionU128Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_16_reducer.rs new file mode 100644 index 00000000000..9c0c7ca7873 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionU16Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionU16Args) -> Self { + Self::DeleteUniqueOptionU16 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionU16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_u_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_u_16 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_16:delete_unique_option_u_16_then`] to run a callback after the reducer completes. + fn delete_unique_option_u_16(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_u_16_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_16_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_u_16 for super::RemoteReducers { + fn delete_unique_option_u_16_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionU16Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_256_reducer.rs new file mode 100644 index 00000000000..3bf40b360d1 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionU256Args { + pub n: Option<__sats::u256>, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionU256Args) -> Self { + Self::DeleteUniqueOptionU256 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionU256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_u_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_u_256 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_256:delete_unique_option_u_256_then`] to run a callback after the reducer completes. + fn delete_unique_option_u_256(&self, n: Option<__sats::u256>) -> __sdk::Result<()> { + self.delete_unique_option_u_256_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_256_then( + &self, + n: Option<__sats::u256>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_u_256 for super::RemoteReducers { + fn delete_unique_option_u_256_then( + &self, + n: Option<__sats::u256>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionU256Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_32_reducer.rs new file mode 100644 index 00000000000..ff033898257 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionU32Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionU32Args) -> Self { + Self::DeleteUniqueOptionU32 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionU32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_u_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_u_32 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_32:delete_unique_option_u_32_then`] to run a callback after the reducer completes. + fn delete_unique_option_u_32(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_u_32_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_32_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_u_32 for super::RemoteReducers { + fn delete_unique_option_u_32_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionU32Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_64_reducer.rs new file mode 100644 index 00000000000..39bd694b31f --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionU64Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionU64Args) -> Self { + Self::DeleteUniqueOptionU64 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionU64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_u_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_u_64 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_64:delete_unique_option_u_64_then`] to run a callback after the reducer completes. + fn delete_unique_option_u_64(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_u_64_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_64_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_u_64 for super::RemoteReducers { + fn delete_unique_option_u_64_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionU64Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_u_8_reducer.rs new file mode 100644 index 00000000000..a0feda39fab --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_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 DeleteUniqueOptionU8Args { + pub n: Option, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionU8Args) -> Self { + Self::DeleteUniqueOptionU8 { n: args.n } + } +} + +impl __sdk::InModule for DeleteUniqueOptionU8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_u_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_u_8 { + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_8:delete_unique_option_u_8_then`] to run a callback after the reducer completes. + fn delete_unique_option_u_8(&self, n: Option) -> __sdk::Result<()> { + self.delete_unique_option_u_8_then(n, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_option_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_unique_option_u_8_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_u_8 for super::RemoteReducers { + fn delete_unique_option_u_8_then( + &self, + n: Option, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(DeleteUniqueOptionU8Args { n }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_uuid_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_option_uuid_reducer.rs new file mode 100644 index 00000000000..81de78dc2a4 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/delete_unique_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 DeleteUniqueOptionUuidArgs { + pub u: Option<__sdk::Uuid>, +} + +impl From for super::Reducer { + fn from(args: DeleteUniqueOptionUuidArgs) -> Self { + Self::DeleteUniqueOptionUuid { u: args.u } + } +} + +impl __sdk::InModule for DeleteUniqueOptionUuidArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `delete_unique_option_uuid`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait delete_unique_option_uuid { + /// Request that the remote module invoke the reducer `delete_unique_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_unique_option_uuid:delete_unique_option_uuid_then`] to run a callback after the reducer completes. + fn delete_unique_option_uuid(&self, u: Option<__sdk::Uuid>) -> __sdk::Result<()> { + self.delete_unique_option_uuid_then(u, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `delete_unique_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_unique_option_uuid_then( + &self, + u: Option<__sdk::Uuid>, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl delete_unique_option_uuid for super::RemoteReducers { + fn delete_unique_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(DeleteUniqueOptionUuidArgs { u }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_bool_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_bool_reducer.rs new file mode 100644 index 00000000000..16ddc0d059e --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionBoolArgs { + pub b: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionBoolArgs) -> Self { + Self::InsertUniqueOptionBool { + b: args.b, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionBoolArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_bool`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_bool { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_bool:insert_unique_option_bool_then`] to run a callback after the reducer completes. + fn insert_unique_option_bool(&self, b: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_bool_then(b, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_bool_then( + &self, + b: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_bool for super::RemoteReducers { + fn insert_unique_option_bool_then( + &self, + b: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionBoolArgs { b, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_connection_id_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_connection_id_reducer.rs new file mode 100644 index 00000000000..38321284cff --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionConnectionIdArgs { + pub a: Option<__sdk::ConnectionId>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionConnectionIdArgs) -> Self { + Self::InsertUniqueOptionConnectionId { + a: args.a, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionConnectionIdArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_connection_id`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_connection_id { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_connection_id:insert_unique_option_connection_id_then`] to run a callback after the reducer completes. + fn insert_unique_option_connection_id(&self, a: Option<__sdk::ConnectionId>, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_connection_id_then(a, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_connection_id_then( + &self, + a: Option<__sdk::ConnectionId>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_connection_id for super::RemoteReducers { + fn insert_unique_option_connection_id_then( + &self, + a: Option<__sdk::ConnectionId>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionConnectionIdArgs { a, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_128_reducer.rs new file mode 100644 index 00000000000..6c1cbf5c7a8 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionI128Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionI128Args) -> Self { + Self::InsertUniqueOptionI128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionI128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_i_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_i_128 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_i_128:insert_unique_option_i_128_then`] to run a callback after the reducer completes. + fn insert_unique_option_i_128(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_i_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_i_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_i_128 for super::RemoteReducers { + fn insert_unique_option_i_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionI128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_16_reducer.rs new file mode 100644 index 00000000000..6474513cbcf --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionI16Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionI16Args) -> Self { + Self::InsertUniqueOptionI16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionI16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_i_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_i_16 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_i_16:insert_unique_option_i_16_then`] to run a callback after the reducer completes. + fn insert_unique_option_i_16(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_i_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_i_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_i_16 for super::RemoteReducers { + fn insert_unique_option_i_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionI16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_256_reducer.rs new file mode 100644 index 00000000000..e6edef77265 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionI256Args { + pub n: Option<__sats::i256>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionI256Args) -> Self { + Self::InsertUniqueOptionI256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionI256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_i_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_i_256 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_i_256:insert_unique_option_i_256_then`] to run a callback after the reducer completes. + fn insert_unique_option_i_256(&self, n: Option<__sats::i256>, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_i_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_i_256_then( + &self, + n: Option<__sats::i256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_i_256 for super::RemoteReducers { + fn insert_unique_option_i_256_then( + &self, + n: Option<__sats::i256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionI256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_32_reducer.rs new file mode 100644 index 00000000000..0b1a99ee1b5 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionI32Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionI32Args) -> Self { + Self::InsertUniqueOptionI32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_i_32 { + /// Request that the remote module invoke the reducer `insert_unique_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 [`insert_unique_option_i_32:insert_unique_option_i_32_then`] to run a callback after the reducer completes. + fn insert_unique_option_i_32(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_i_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_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 insert_unique_option_i_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_i_32 for super::RemoteReducers { + fn insert_unique_option_i_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionI32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_64_reducer.rs new file mode 100644 index 00000000000..8770a9eb365 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionI64Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionI64Args) -> Self { + Self::InsertUniqueOptionI64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionI64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_i_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_i_64 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_i_64:insert_unique_option_i_64_then`] to run a callback after the reducer completes. + fn insert_unique_option_i_64(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_i_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_i_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_i_64 for super::RemoteReducers { + fn insert_unique_option_i_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionI64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_i_8_reducer.rs new file mode 100644 index 00000000000..6205b86d7b4 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionI8Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionI8Args) -> Self { + Self::InsertUniqueOptionI8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionI8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_i_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_i_8 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_i_8:insert_unique_option_i_8_then`] to run a callback after the reducer completes. + fn insert_unique_option_i_8(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_i_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_i_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_i_8 for super::RemoteReducers { + fn insert_unique_option_i_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionI8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_identity_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_identity_reducer.rs new file mode 100644 index 00000000000..2695de08033 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionIdentityArgs { + pub i: Option<__sdk::Identity>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionIdentityArgs) -> Self { + Self::InsertUniqueOptionIdentity { + i: args.i, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionIdentityArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_identity`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_identity { + /// Request that the remote module invoke the reducer `insert_unique_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 [`insert_unique_option_identity:insert_unique_option_identity_then`] to run a callback after the reducer completes. + fn insert_unique_option_identity(&self, i: Option<__sdk::Identity>, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_identity_then(i, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_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 insert_unique_option_identity_then( + &self, + i: Option<__sdk::Identity>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_identity for super::RemoteReducers { + fn insert_unique_option_identity_then( + &self, + i: Option<__sdk::Identity>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionIdentityArgs { i, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_string_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_string_reducer.rs new file mode 100644 index 00000000000..285092dc448 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionStringArgs { + pub s: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionStringArgs) -> Self { + Self::InsertUniqueOptionString { + s: args.s, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionStringArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_string`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_string { + /// Request that the remote module invoke the reducer `insert_unique_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 [`insert_unique_option_string:insert_unique_option_string_then`] to run a callback after the reducer completes. + fn insert_unique_option_string(&self, s: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_string_then(s, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_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 insert_unique_option_string_then( + &self, + s: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_string for super::RemoteReducers { + fn insert_unique_option_string_then( + &self, + s: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionStringArgs { s, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_128_reducer.rs new file mode 100644 index 00000000000..6ba57e64b82 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionU128Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionU128Args) -> Self { + Self::InsertUniqueOptionU128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionU128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_u_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_u_128 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_u_128:insert_unique_option_u_128_then`] to run a callback after the reducer completes. + fn insert_unique_option_u_128(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_u_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_u_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_u_128 for super::RemoteReducers { + fn insert_unique_option_u_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionU128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_16_reducer.rs new file mode 100644 index 00000000000..bfcf20f0df8 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionU16Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionU16Args) -> Self { + Self::InsertUniqueOptionU16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionU16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_u_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_u_16 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_u_16:insert_unique_option_u_16_then`] to run a callback after the reducer completes. + fn insert_unique_option_u_16(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_u_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_u_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_u_16 for super::RemoteReducers { + fn insert_unique_option_u_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionU16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_256_reducer.rs new file mode 100644 index 00000000000..a7cbb946df3 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionU256Args { + pub n: Option<__sats::u256>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionU256Args) -> Self { + Self::InsertUniqueOptionU256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionU256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_u_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_u_256 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_u_256:insert_unique_option_u_256_then`] to run a callback after the reducer completes. + fn insert_unique_option_u_256(&self, n: Option<__sats::u256>, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_u_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_u_256_then( + &self, + n: Option<__sats::u256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_u_256 for super::RemoteReducers { + fn insert_unique_option_u_256_then( + &self, + n: Option<__sats::u256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionU256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_32_reducer.rs new file mode 100644 index 00000000000..996415b49cb --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionU32Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionU32Args) -> Self { + Self::InsertUniqueOptionU32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionU32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_u_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_u_32 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_u_32:insert_unique_option_u_32_then`] to run a callback after the reducer completes. + fn insert_unique_option_u_32(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_u_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_u_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_u_32 for super::RemoteReducers { + fn insert_unique_option_u_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionU32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_64_reducer.rs new file mode 100644 index 00000000000..6b49a5f28cd --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionU64Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionU64Args) -> Self { + Self::InsertUniqueOptionU64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionU64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_u_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_u_64 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_u_64:insert_unique_option_u_64_then`] to run a callback after the reducer completes. + fn insert_unique_option_u_64(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_u_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_u_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_u_64 for super::RemoteReducers { + fn insert_unique_option_u_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionU64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_u_8_reducer.rs new file mode 100644 index 00000000000..3f75b85f005 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionU8Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionU8Args) -> Self { + Self::InsertUniqueOptionU8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionU8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_u_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_u_8 { + /// Request that the remote module invoke the reducer `insert_unique_option_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 [`insert_unique_option_u_8:insert_unique_option_u_8_then`] to run a callback after the reducer completes. + fn insert_unique_option_u_8(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_u_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_option_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 insert_unique_option_u_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_u_8 for super::RemoteReducers { + fn insert_unique_option_u_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionU8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_uuid_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_uuid_reducer.rs new file mode 100644 index 00000000000..666c2f51b33 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/insert_unique_option_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 InsertUniqueOptionUuidArgs { + pub u: Option<__sdk::Uuid>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: InsertUniqueOptionUuidArgs) -> Self { + Self::InsertUniqueOptionUuid { + u: args.u, + data: args.data, + } + } +} + +impl __sdk::InModule for InsertUniqueOptionUuidArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `insert_unique_option_uuid`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait insert_unique_option_uuid { + /// Request that the remote module invoke the reducer `insert_unique_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 [`insert_unique_option_uuid:insert_unique_option_uuid_then`] to run a callback after the reducer completes. + fn insert_unique_option_uuid(&self, u: Option<__sdk::Uuid>, data: i32) -> __sdk::Result<()> { + self.insert_unique_option_uuid_then(u, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `insert_unique_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 insert_unique_option_uuid_then( + &self, + u: Option<__sdk::Uuid>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl insert_unique_option_uuid for super::RemoteReducers { + fn insert_unique_option_uuid_then( + &self, + u: Option<__sdk::Uuid>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(InsertUniqueOptionUuidArgs { u, data }, callback) + } +} 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..5f13714be6a 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.7.0 (commit 20cbf4da6db0000de5155371c9b79185217c8999). #![allow(unused, clippy::all)] use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; @@ -9,6 +9,115 @@ 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_option_bool_reducer; +pub mod delete_all_unique_option_connection_id_reducer; +pub mod delete_all_unique_option_i_128_reducer; +pub mod delete_all_unique_option_i_16_reducer; +pub mod delete_all_unique_option_i_256_reducer; +pub mod delete_all_unique_option_i_32_reducer; +pub mod delete_all_unique_option_i_64_reducer; +pub mod delete_all_unique_option_i_8_reducer; +pub mod delete_all_unique_option_identity_reducer; +pub mod delete_all_unique_option_string_reducer; +pub mod delete_all_unique_option_u_128_reducer; +pub mod delete_all_unique_option_u_16_reducer; +pub mod delete_all_unique_option_u_256_reducer; +pub mod delete_all_unique_option_u_32_reducer; +pub mod delete_all_unique_option_u_64_reducer; +pub mod delete_all_unique_option_u_8_reducer; +pub mod delete_all_unique_option_uuid_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; @@ -39,6 +148,23 @@ pub mod delete_unique_i_32_reducer; pub mod delete_unique_i_64_reducer; pub mod delete_unique_i_8_reducer; pub mod delete_unique_identity_reducer; +pub mod delete_unique_option_bool_reducer; +pub mod delete_unique_option_connection_id_reducer; +pub mod delete_unique_option_i_128_reducer; +pub mod delete_unique_option_i_16_reducer; +pub mod delete_unique_option_i_256_reducer; +pub mod delete_unique_option_i_32_reducer; +pub mod delete_unique_option_i_64_reducer; +pub mod delete_unique_option_i_8_reducer; +pub mod delete_unique_option_identity_reducer; +pub mod delete_unique_option_string_reducer; +pub mod delete_unique_option_u_128_reducer; +pub mod delete_unique_option_u_16_reducer; +pub mod delete_unique_option_u_256_reducer; +pub mod delete_unique_option_u_32_reducer; +pub mod delete_unique_option_u_64_reducer; +pub mod delete_unique_option_u_8_reducer; +pub mod delete_unique_option_uuid_reducer; pub mod delete_unique_string_reducer; pub mod delete_unique_u_128_reducer; pub mod delete_unique_u_16_reducer; @@ -140,6 +266,23 @@ pub mod insert_unique_i_32_reducer; pub mod insert_unique_i_64_reducer; pub mod insert_unique_i_8_reducer; pub mod insert_unique_identity_reducer; +pub mod insert_unique_option_bool_reducer; +pub mod insert_unique_option_connection_id_reducer; +pub mod insert_unique_option_i_128_reducer; +pub mod insert_unique_option_i_16_reducer; +pub mod insert_unique_option_i_256_reducer; +pub mod insert_unique_option_i_32_reducer; +pub mod insert_unique_option_i_64_reducer; +pub mod insert_unique_option_i_8_reducer; +pub mod insert_unique_option_identity_reducer; +pub mod insert_unique_option_string_reducer; +pub mod insert_unique_option_u_128_reducer; +pub mod insert_unique_option_u_16_reducer; +pub mod insert_unique_option_u_256_reducer; +pub mod insert_unique_option_u_32_reducer; +pub mod insert_unique_option_u_64_reducer; +pub mod insert_unique_option_u_8_reducer; +pub mod insert_unique_option_uuid_reducer; pub mod insert_unique_string_reducer; pub mod insert_unique_u_128_reducer; pub mod insert_unique_u_16_reducer; @@ -320,6 +463,40 @@ pub mod unique_i_8_table; pub mod unique_i_8_type; pub mod unique_identity_table; pub mod unique_identity_type; +pub mod unique_option_bool_table; +pub mod unique_option_bool_type; +pub mod unique_option_connection_id_table; +pub mod unique_option_connection_id_type; +pub mod unique_option_i_128_table; +pub mod unique_option_i_128_type; +pub mod unique_option_i_16_table; +pub mod unique_option_i_16_type; +pub mod unique_option_i_256_table; +pub mod unique_option_i_256_type; +pub mod unique_option_i_32_table; +pub mod unique_option_i_32_type; +pub mod unique_option_i_64_table; +pub mod unique_option_i_64_type; +pub mod unique_option_i_8_table; +pub mod unique_option_i_8_type; +pub mod unique_option_identity_table; +pub mod unique_option_identity_type; +pub mod unique_option_string_table; +pub mod unique_option_string_type; +pub mod unique_option_u_128_table; +pub mod unique_option_u_128_type; +pub mod unique_option_u_16_table; +pub mod unique_option_u_16_type; +pub mod unique_option_u_256_table; +pub mod unique_option_u_256_type; +pub mod unique_option_u_32_table; +pub mod unique_option_u_32_type; +pub mod unique_option_u_64_table; +pub mod unique_option_u_64_type; +pub mod unique_option_u_8_table; +pub mod unique_option_u_8_type; +pub mod unique_option_uuid_table; +pub mod unique_option_uuid_type; pub mod unique_string_table; pub mod unique_string_type; pub mod unique_u_128_table; @@ -366,6 +543,23 @@ pub mod update_unique_i_32_reducer; pub mod update_unique_i_64_reducer; pub mod update_unique_i_8_reducer; pub mod update_unique_identity_reducer; +pub mod update_unique_option_bool_reducer; +pub mod update_unique_option_connection_id_reducer; +pub mod update_unique_option_i_128_reducer; +pub mod update_unique_option_i_16_reducer; +pub mod update_unique_option_i_256_reducer; +pub mod update_unique_option_i_32_reducer; +pub mod update_unique_option_i_64_reducer; +pub mod update_unique_option_i_8_reducer; +pub mod update_unique_option_identity_reducer; +pub mod update_unique_option_string_reducer; +pub mod update_unique_option_u_128_reducer; +pub mod update_unique_option_u_16_reducer; +pub mod update_unique_option_u_256_reducer; +pub mod update_unique_option_u_32_reducer; +pub mod update_unique_option_u_64_reducer; +pub mod update_unique_option_u_8_reducer; +pub mod update_unique_option_uuid_reducer; pub mod update_unique_string_reducer; pub mod update_unique_u_128_reducer; pub mod update_unique_u_16_reducer; @@ -432,6 +626,115 @@ 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_option_bool_reducer::delete_all_unique_option_bool; +pub use delete_all_unique_option_connection_id_reducer::delete_all_unique_option_connection_id; +pub use delete_all_unique_option_i_128_reducer::delete_all_unique_option_i_128; +pub use delete_all_unique_option_i_16_reducer::delete_all_unique_option_i_16; +pub use delete_all_unique_option_i_256_reducer::delete_all_unique_option_i_256; +pub use delete_all_unique_option_i_32_reducer::delete_all_unique_option_i_32; +pub use delete_all_unique_option_i_64_reducer::delete_all_unique_option_i_64; +pub use delete_all_unique_option_i_8_reducer::delete_all_unique_option_i_8; +pub use delete_all_unique_option_identity_reducer::delete_all_unique_option_identity; +pub use delete_all_unique_option_string_reducer::delete_all_unique_option_string; +pub use delete_all_unique_option_u_128_reducer::delete_all_unique_option_u_128; +pub use delete_all_unique_option_u_16_reducer::delete_all_unique_option_u_16; +pub use delete_all_unique_option_u_256_reducer::delete_all_unique_option_u_256; +pub use delete_all_unique_option_u_32_reducer::delete_all_unique_option_u_32; +pub use delete_all_unique_option_u_64_reducer::delete_all_unique_option_u_64; +pub use delete_all_unique_option_u_8_reducer::delete_all_unique_option_u_8; +pub use delete_all_unique_option_uuid_reducer::delete_all_unique_option_uuid; +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; @@ -462,6 +765,23 @@ pub use delete_unique_i_32_reducer::delete_unique_i_32; pub use delete_unique_i_64_reducer::delete_unique_i_64; pub use delete_unique_i_8_reducer::delete_unique_i_8; pub use delete_unique_identity_reducer::delete_unique_identity; +pub use delete_unique_option_bool_reducer::delete_unique_option_bool; +pub use delete_unique_option_connection_id_reducer::delete_unique_option_connection_id; +pub use delete_unique_option_i_128_reducer::delete_unique_option_i_128; +pub use delete_unique_option_i_16_reducer::delete_unique_option_i_16; +pub use delete_unique_option_i_256_reducer::delete_unique_option_i_256; +pub use delete_unique_option_i_32_reducer::delete_unique_option_i_32; +pub use delete_unique_option_i_64_reducer::delete_unique_option_i_64; +pub use delete_unique_option_i_8_reducer::delete_unique_option_i_8; +pub use delete_unique_option_identity_reducer::delete_unique_option_identity; +pub use delete_unique_option_string_reducer::delete_unique_option_string; +pub use delete_unique_option_u_128_reducer::delete_unique_option_u_128; +pub use delete_unique_option_u_16_reducer::delete_unique_option_u_16; +pub use delete_unique_option_u_256_reducer::delete_unique_option_u_256; +pub use delete_unique_option_u_32_reducer::delete_unique_option_u_32; +pub use delete_unique_option_u_64_reducer::delete_unique_option_u_64; +pub use delete_unique_option_u_8_reducer::delete_unique_option_u_8; +pub use delete_unique_option_uuid_reducer::delete_unique_option_uuid; pub use delete_unique_string_reducer::delete_unique_string; pub use delete_unique_u_128_reducer::delete_unique_u_128; pub use delete_unique_u_16_reducer::delete_unique_u_16; @@ -563,6 +883,23 @@ pub use insert_unique_i_32_reducer::insert_unique_i_32; pub use insert_unique_i_64_reducer::insert_unique_i_64; pub use insert_unique_i_8_reducer::insert_unique_i_8; pub use insert_unique_identity_reducer::insert_unique_identity; +pub use insert_unique_option_bool_reducer::insert_unique_option_bool; +pub use insert_unique_option_connection_id_reducer::insert_unique_option_connection_id; +pub use insert_unique_option_i_128_reducer::insert_unique_option_i_128; +pub use insert_unique_option_i_16_reducer::insert_unique_option_i_16; +pub use insert_unique_option_i_256_reducer::insert_unique_option_i_256; +pub use insert_unique_option_i_32_reducer::insert_unique_option_i_32; +pub use insert_unique_option_i_64_reducer::insert_unique_option_i_64; +pub use insert_unique_option_i_8_reducer::insert_unique_option_i_8; +pub use insert_unique_option_identity_reducer::insert_unique_option_identity; +pub use insert_unique_option_string_reducer::insert_unique_option_string; +pub use insert_unique_option_u_128_reducer::insert_unique_option_u_128; +pub use insert_unique_option_u_16_reducer::insert_unique_option_u_16; +pub use insert_unique_option_u_256_reducer::insert_unique_option_u_256; +pub use insert_unique_option_u_32_reducer::insert_unique_option_u_32; +pub use insert_unique_option_u_64_reducer::insert_unique_option_u_64; +pub use insert_unique_option_u_8_reducer::insert_unique_option_u_8; +pub use insert_unique_option_uuid_reducer::insert_unique_option_uuid; pub use insert_unique_string_reducer::insert_unique_string; pub use insert_unique_u_128_reducer::insert_unique_u_128; pub use insert_unique_u_16_reducer::insert_unique_u_16; @@ -743,6 +1080,40 @@ pub use unique_i_8_table::*; pub use unique_i_8_type::UniqueI8; pub use unique_identity_table::*; pub use unique_identity_type::UniqueIdentity; +pub use unique_option_bool_table::*; +pub use unique_option_bool_type::UniqueOptionBool; +pub use unique_option_connection_id_table::*; +pub use unique_option_connection_id_type::UniqueOptionConnectionId; +pub use unique_option_i_128_table::*; +pub use unique_option_i_128_type::UniqueOptionI128; +pub use unique_option_i_16_table::*; +pub use unique_option_i_16_type::UniqueOptionI16; +pub use unique_option_i_256_table::*; +pub use unique_option_i_256_type::UniqueOptionI256; +pub use unique_option_i_32_table::*; +pub use unique_option_i_32_type::UniqueOptionI32; +pub use unique_option_i_64_table::*; +pub use unique_option_i_64_type::UniqueOptionI64; +pub use unique_option_i_8_table::*; +pub use unique_option_i_8_type::UniqueOptionI8; +pub use unique_option_identity_table::*; +pub use unique_option_identity_type::UniqueOptionIdentity; +pub use unique_option_string_table::*; +pub use unique_option_string_type::UniqueOptionString; +pub use unique_option_u_128_table::*; +pub use unique_option_u_128_type::UniqueOptionU128; +pub use unique_option_u_16_table::*; +pub use unique_option_u_16_type::UniqueOptionU16; +pub use unique_option_u_256_table::*; +pub use unique_option_u_256_type::UniqueOptionU256; +pub use unique_option_u_32_table::*; +pub use unique_option_u_32_type::UniqueOptionU32; +pub use unique_option_u_64_table::*; +pub use unique_option_u_64_type::UniqueOptionU64; +pub use unique_option_u_8_table::*; +pub use unique_option_u_8_type::UniqueOptionU8; +pub use unique_option_uuid_table::*; +pub use unique_option_uuid_type::UniqueOptionUuid; pub use unique_string_table::*; pub use unique_string_type::UniqueString; pub use unique_u_128_table::*; @@ -789,6 +1160,23 @@ pub use update_unique_i_32_reducer::update_unique_i_32; pub use update_unique_i_64_reducer::update_unique_i_64; pub use update_unique_i_8_reducer::update_unique_i_8; pub use update_unique_identity_reducer::update_unique_identity; +pub use update_unique_option_bool_reducer::update_unique_option_bool; +pub use update_unique_option_connection_id_reducer::update_unique_option_connection_id; +pub use update_unique_option_i_128_reducer::update_unique_option_i_128; +pub use update_unique_option_i_16_reducer::update_unique_option_i_16; +pub use update_unique_option_i_256_reducer::update_unique_option_i_256; +pub use update_unique_option_i_32_reducer::update_unique_option_i_32; +pub use update_unique_option_i_64_reducer::update_unique_option_i_64; +pub use update_unique_option_i_8_reducer::update_unique_option_i_8; +pub use update_unique_option_identity_reducer::update_unique_option_identity; +pub use update_unique_option_string_reducer::update_unique_option_string; +pub use update_unique_option_u_128_reducer::update_unique_option_u_128; +pub use update_unique_option_u_16_reducer::update_unique_option_u_16; +pub use update_unique_option_u_256_reducer::update_unique_option_u_256; +pub use update_unique_option_u_32_reducer::update_unique_option_u_32; +pub use update_unique_option_u_64_reducer::update_unique_option_u_64; +pub use update_unique_option_u_8_reducer::update_unique_option_u_8; +pub use update_unique_option_uuid_reducer::update_unique_option_uuid; pub use update_unique_string_reducer::update_unique_string; pub use update_unique_u_128_reducer::update_unique_u_128; pub use update_unique_u_16_reducer::update_unique_u_16; @@ -860,6 +1248,385 @@ 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, + }, + DeleteAllUniqueOptionBool { + b: Option, + data: i32, + }, + DeleteAllUniqueOptionConnectionId { + a: Option<__sdk::ConnectionId>, + data: i32, + }, + DeleteAllUniqueOptionI128 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionI16 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionI256 { + n: Option<__sats::i256>, + data: i32, + }, + DeleteAllUniqueOptionI32 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionI64 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionI8 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionIdentity { + i: Option<__sdk::Identity>, + data: i32, + }, + DeleteAllUniqueOptionString { + s: Option, + data: i32, + }, + DeleteAllUniqueOptionU128 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionU16 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionU256 { + n: Option<__sats::u256>, + data: i32, + }, + DeleteAllUniqueOptionU32 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionU64 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionU8 { + n: Option, + data: i32, + }, + DeleteAllUniqueOptionUuid { + u: Option<__sdk::Uuid>, + 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, }, @@ -972,6 +1739,57 @@ pub enum Reducer { DeleteUniqueIdentity { i: __sdk::Identity, }, + DeleteUniqueOptionBool { + b: Option, + }, + DeleteUniqueOptionConnectionId { + a: Option<__sdk::ConnectionId>, + }, + DeleteUniqueOptionI128 { + n: Option, + }, + DeleteUniqueOptionI16 { + n: Option, + }, + DeleteUniqueOptionI256 { + n: Option<__sats::i256>, + }, + DeleteUniqueOptionI32 { + n: Option, + }, + DeleteUniqueOptionI64 { + n: Option, + }, + DeleteUniqueOptionI8 { + n: Option, + }, + DeleteUniqueOptionIdentity { + i: Option<__sdk::Identity>, + }, + DeleteUniqueOptionString { + s: Option, + }, + DeleteUniqueOptionU128 { + n: Option, + }, + DeleteUniqueOptionU16 { + n: Option, + }, + DeleteUniqueOptionU256 { + n: Option<__sats::u256>, + }, + DeleteUniqueOptionU32 { + n: Option, + }, + DeleteUniqueOptionU64 { + n: Option, + }, + DeleteUniqueOptionU8 { + n: Option, + }, + DeleteUniqueOptionUuid { + u: Option<__sdk::Uuid>, + }, DeleteUniqueString { s: String, }, @@ -1285,6 +2103,74 @@ pub enum Reducer { i: __sdk::Identity, data: i32, }, + InsertUniqueOptionBool { + b: Option, + data: i32, + }, + InsertUniqueOptionConnectionId { + a: Option<__sdk::ConnectionId>, + data: i32, + }, + InsertUniqueOptionI128 { + n: Option, + data: i32, + }, + InsertUniqueOptionI16 { + n: Option, + data: i32, + }, + InsertUniqueOptionI256 { + n: Option<__sats::i256>, + data: i32, + }, + InsertUniqueOptionI32 { + n: Option, + data: i32, + }, + InsertUniqueOptionI64 { + n: Option, + data: i32, + }, + InsertUniqueOptionI8 { + n: Option, + data: i32, + }, + InsertUniqueOptionIdentity { + i: Option<__sdk::Identity>, + data: i32, + }, + InsertUniqueOptionString { + s: Option, + data: i32, + }, + InsertUniqueOptionU128 { + n: Option, + data: i32, + }, + InsertUniqueOptionU16 { + n: Option, + data: i32, + }, + InsertUniqueOptionU256 { + n: Option<__sats::u256>, + data: i32, + }, + InsertUniqueOptionU32 { + n: Option, + data: i32, + }, + InsertUniqueOptionU64 { + n: Option, + data: i32, + }, + InsertUniqueOptionU8 { + n: Option, + data: i32, + }, + InsertUniqueOptionUuid { + u: Option<__sdk::Uuid>, + data: i32, + }, InsertUniqueString { s: String, data: i32, @@ -1461,68 +2347,136 @@ pub enum Reducer { n: u128, data: i32, }, - UpdatePkU16 { - n: u16, + UpdatePkU16 { + n: u16, + data: i32, + }, + UpdatePkU256 { + n: __sats::u256, + data: i32, + }, + UpdatePkU32 { + n: u32, + data: i32, + }, + UpdatePkU32Two { + n: u32, + data: i32, + }, + UpdatePkU64 { + n: u64, + data: i32, + }, + UpdatePkU8 { + n: u8, + data: i32, + }, + UpdatePkUuid { + u: __sdk::Uuid, + data: i32, + }, + UpdateUniqueBool { + b: bool, + data: i32, + }, + UpdateUniqueConnectionId { + a: __sdk::ConnectionId, + data: i32, + }, + UpdateUniqueI128 { + n: i128, + data: i32, + }, + UpdateUniqueI16 { + n: i16, + data: i32, + }, + UpdateUniqueI256 { + n: __sats::i256, + data: i32, + }, + UpdateUniqueI32 { + n: i32, + data: i32, + }, + UpdateUniqueI64 { + n: i64, + data: i32, + }, + UpdateUniqueI8 { + n: i8, + data: i32, + }, + UpdateUniqueIdentity { + i: __sdk::Identity, + data: i32, + }, + UpdateUniqueOptionBool { + b: Option, + data: i32, + }, + UpdateUniqueOptionConnectionId { + a: Option<__sdk::ConnectionId>, data: i32, }, - UpdatePkU256 { - n: __sats::u256, + UpdateUniqueOptionI128 { + n: Option, data: i32, }, - UpdatePkU32 { - n: u32, + UpdateUniqueOptionI16 { + n: Option, data: i32, }, - UpdatePkU32Two { - n: u32, + UpdateUniqueOptionI256 { + n: Option<__sats::i256>, data: i32, }, - UpdatePkU64 { - n: u64, + UpdateUniqueOptionI32 { + n: Option, data: i32, }, - UpdatePkU8 { - n: u8, + UpdateUniqueOptionI64 { + n: Option, data: i32, }, - UpdatePkUuid { - u: __sdk::Uuid, + UpdateUniqueOptionI8 { + n: Option, data: i32, }, - UpdateUniqueBool { - b: bool, + UpdateUniqueOptionIdentity { + i: Option<__sdk::Identity>, data: i32, }, - UpdateUniqueConnectionId { - a: __sdk::ConnectionId, + UpdateUniqueOptionString { + s: Option, data: i32, }, - UpdateUniqueI128 { - n: i128, + UpdateUniqueOptionU128 { + n: Option, data: i32, }, - UpdateUniqueI16 { - n: i16, + UpdateUniqueOptionU16 { + n: Option, data: i32, }, - UpdateUniqueI256 { - n: __sats::i256, + UpdateUniqueOptionU256 { + n: Option<__sats::u256>, data: i32, }, - UpdateUniqueI32 { - n: i32, + UpdateUniqueOptionU32 { + n: Option, data: i32, }, - UpdateUniqueI64 { - n: i64, + UpdateUniqueOptionU64 { + n: Option, data: i32, }, - UpdateUniqueI8 { - n: i8, + UpdateUniqueOptionU8 { + n: Option, data: i32, }, - UpdateUniqueIdentity { - i: __sdk::Identity, + UpdateUniqueOptionUuid { + u: Option<__sdk::Uuid>, data: i32, }, UpdateUniqueString { @@ -1566,6 +2520,115 @@ 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::DeleteAllUniqueOptionBool { .. } => "delete_all_unique_option_bool", + Reducer::DeleteAllUniqueOptionConnectionId { .. } => "delete_all_unique_option_connection_id", + Reducer::DeleteAllUniqueOptionI128 { .. } => "delete_all_unique_option_i_128", + Reducer::DeleteAllUniqueOptionI16 { .. } => "delete_all_unique_option_i_16", + Reducer::DeleteAllUniqueOptionI256 { .. } => "delete_all_unique_option_i_256", + Reducer::DeleteAllUniqueOptionI32 { .. } => "delete_all_unique_option_i_32", + Reducer::DeleteAllUniqueOptionI64 { .. } => "delete_all_unique_option_i_64", + Reducer::DeleteAllUniqueOptionI8 { .. } => "delete_all_unique_option_i_8", + Reducer::DeleteAllUniqueOptionIdentity { .. } => "delete_all_unique_option_identity", + Reducer::DeleteAllUniqueOptionString { .. } => "delete_all_unique_option_string", + Reducer::DeleteAllUniqueOptionU128 { .. } => "delete_all_unique_option_u_128", + Reducer::DeleteAllUniqueOptionU16 { .. } => "delete_all_unique_option_u_16", + Reducer::DeleteAllUniqueOptionU256 { .. } => "delete_all_unique_option_u_256", + Reducer::DeleteAllUniqueOptionU32 { .. } => "delete_all_unique_option_u_32", + Reducer::DeleteAllUniqueOptionU64 { .. } => "delete_all_unique_option_u_64", + Reducer::DeleteAllUniqueOptionU8 { .. } => "delete_all_unique_option_u_8", + Reducer::DeleteAllUniqueOptionUuid { .. } => "delete_all_unique_option_uuid", + 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", @@ -1596,6 +2659,23 @@ impl __sdk::Reducer for Reducer { Reducer::DeleteUniqueI64 { .. } => "delete_unique_i_64", Reducer::DeleteUniqueI8 { .. } => "delete_unique_i_8", Reducer::DeleteUniqueIdentity { .. } => "delete_unique_identity", + Reducer::DeleteUniqueOptionBool { .. } => "delete_unique_option_bool", + Reducer::DeleteUniqueOptionConnectionId { .. } => "delete_unique_option_connection_id", + Reducer::DeleteUniqueOptionI128 { .. } => "delete_unique_option_i_128", + Reducer::DeleteUniqueOptionI16 { .. } => "delete_unique_option_i_16", + Reducer::DeleteUniqueOptionI256 { .. } => "delete_unique_option_i_256", + Reducer::DeleteUniqueOptionI32 { .. } => "delete_unique_option_i_32", + Reducer::DeleteUniqueOptionI64 { .. } => "delete_unique_option_i_64", + Reducer::DeleteUniqueOptionI8 { .. } => "delete_unique_option_i_8", + Reducer::DeleteUniqueOptionIdentity { .. } => "delete_unique_option_identity", + Reducer::DeleteUniqueOptionString { .. } => "delete_unique_option_string", + Reducer::DeleteUniqueOptionU128 { .. } => "delete_unique_option_u_128", + Reducer::DeleteUniqueOptionU16 { .. } => "delete_unique_option_u_16", + Reducer::DeleteUniqueOptionU256 { .. } => "delete_unique_option_u_256", + Reducer::DeleteUniqueOptionU32 { .. } => "delete_unique_option_u_32", + Reducer::DeleteUniqueOptionU64 { .. } => "delete_unique_option_u_64", + Reducer::DeleteUniqueOptionU8 { .. } => "delete_unique_option_u_8", + Reducer::DeleteUniqueOptionUuid { .. } => "delete_unique_option_uuid", Reducer::DeleteUniqueString { .. } => "delete_unique_string", Reducer::DeleteUniqueU128 { .. } => "delete_unique_u_128", Reducer::DeleteUniqueU16 { .. } => "delete_unique_u_16", @@ -1688,6 +2768,23 @@ impl __sdk::Reducer for Reducer { Reducer::InsertUniqueI64 { .. } => "insert_unique_i_64", Reducer::InsertUniqueI8 { .. } => "insert_unique_i_8", Reducer::InsertUniqueIdentity { .. } => "insert_unique_identity", + Reducer::InsertUniqueOptionBool { .. } => "insert_unique_option_bool", + Reducer::InsertUniqueOptionConnectionId { .. } => "insert_unique_option_connection_id", + Reducer::InsertUniqueOptionI128 { .. } => "insert_unique_option_i_128", + Reducer::InsertUniqueOptionI16 { .. } => "insert_unique_option_i_16", + Reducer::InsertUniqueOptionI256 { .. } => "insert_unique_option_i_256", + Reducer::InsertUniqueOptionI32 { .. } => "insert_unique_option_i_32", + Reducer::InsertUniqueOptionI64 { .. } => "insert_unique_option_i_64", + Reducer::InsertUniqueOptionI8 { .. } => "insert_unique_option_i_8", + Reducer::InsertUniqueOptionIdentity { .. } => "insert_unique_option_identity", + Reducer::InsertUniqueOptionString { .. } => "insert_unique_option_string", + Reducer::InsertUniqueOptionU128 { .. } => "insert_unique_option_u_128", + Reducer::InsertUniqueOptionU16 { .. } => "insert_unique_option_u_16", + Reducer::InsertUniqueOptionU256 { .. } => "insert_unique_option_u_256", + Reducer::InsertUniqueOptionU32 { .. } => "insert_unique_option_u_32", + Reducer::InsertUniqueOptionU64 { .. } => "insert_unique_option_u_64", + Reducer::InsertUniqueOptionU8 { .. } => "insert_unique_option_u_8", + Reducer::InsertUniqueOptionUuid { .. } => "insert_unique_option_uuid", Reducer::InsertUniqueString { .. } => "insert_unique_string", Reducer::InsertUniqueU128 { .. } => "insert_unique_u_128", Reducer::InsertUniqueU16 { .. } => "insert_unique_u_16", @@ -1756,6 +2853,23 @@ impl __sdk::Reducer for Reducer { Reducer::UpdateUniqueI64 { .. } => "update_unique_i_64", Reducer::UpdateUniqueI8 { .. } => "update_unique_i_8", Reducer::UpdateUniqueIdentity { .. } => "update_unique_identity", + Reducer::UpdateUniqueOptionBool { .. } => "update_unique_option_bool", + Reducer::UpdateUniqueOptionConnectionId { .. } => "update_unique_option_connection_id", + Reducer::UpdateUniqueOptionI128 { .. } => "update_unique_option_i_128", + Reducer::UpdateUniqueOptionI16 { .. } => "update_unique_option_i_16", + Reducer::UpdateUniqueOptionI256 { .. } => "update_unique_option_i_256", + Reducer::UpdateUniqueOptionI32 { .. } => "update_unique_option_i_32", + Reducer::UpdateUniqueOptionI64 { .. } => "update_unique_option_i_64", + Reducer::UpdateUniqueOptionI8 { .. } => "update_unique_option_i_8", + Reducer::UpdateUniqueOptionIdentity { .. } => "update_unique_option_identity", + Reducer::UpdateUniqueOptionString { .. } => "update_unique_option_string", + Reducer::UpdateUniqueOptionU128 { .. } => "update_unique_option_u_128", + Reducer::UpdateUniqueOptionU16 { .. } => "update_unique_option_u_16", + Reducer::UpdateUniqueOptionU256 { .. } => "update_unique_option_u_256", + Reducer::UpdateUniqueOptionU32 { .. } => "update_unique_option_u_32", + Reducer::UpdateUniqueOptionU64 { .. } => "update_unique_option_u_64", + Reducer::UpdateUniqueOptionU8 { .. } => "update_unique_option_u_8", + Reducer::UpdateUniqueOptionUuid { .. } => "update_unique_option_uuid", Reducer::UpdateUniqueString { .. } => "update_unique_string", Reducer::UpdateUniqueU128 { .. } => "update_unique_u_128", Reducer::UpdateUniqueU16 { .. } => "update_unique_u_16", @@ -1770,6 +2884,493 @@ 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::DeleteAllUniqueOptionBool { b, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_bool_reducer::DeleteAllUniqueOptionBoolArgs { + b: b.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionConnectionId { a, data } => __sats::bsatn::to_vec( + &delete_all_unique_option_connection_id_reducer::DeleteAllUniqueOptionConnectionIdArgs { + a: a.clone(), + data: data.clone(), + }, + ), + Reducer::DeleteAllUniqueOptionI128 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_i_128_reducer::DeleteAllUniqueOptionI128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionI16 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_i_16_reducer::DeleteAllUniqueOptionI16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionI256 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_i_256_reducer::DeleteAllUniqueOptionI256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionI32 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_i_32_reducer::DeleteAllUniqueOptionI32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionI64 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_i_64_reducer::DeleteAllUniqueOptionI64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionI8 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_i_8_reducer::DeleteAllUniqueOptionI8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionIdentity { i, data } => __sats::bsatn::to_vec( + &delete_all_unique_option_identity_reducer::DeleteAllUniqueOptionIdentityArgs { + i: i.clone(), + data: data.clone(), + }, + ), + Reducer::DeleteAllUniqueOptionString { s, data } => __sats::bsatn::to_vec( + &delete_all_unique_option_string_reducer::DeleteAllUniqueOptionStringArgs { + s: s.clone(), + data: data.clone(), + }, + ), + Reducer::DeleteAllUniqueOptionU128 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_u_128_reducer::DeleteAllUniqueOptionU128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionU16 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_u_16_reducer::DeleteAllUniqueOptionU16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionU256 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_u_256_reducer::DeleteAllUniqueOptionU256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionU32 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_u_32_reducer::DeleteAllUniqueOptionU32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionU64 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_u_64_reducer::DeleteAllUniqueOptionU64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionU8 { n, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_u_8_reducer::DeleteAllUniqueOptionU8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::DeleteAllUniqueOptionUuid { u, data } => { + __sats::bsatn::to_vec(&delete_all_unique_option_uuid_reducer::DeleteAllUniqueOptionUuidArgs { + u: u.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() }) } @@ -1905,6 +3506,61 @@ impl __sdk::Reducer for Reducer { Reducer::DeleteUniqueIdentity { i } => { __sats::bsatn::to_vec(&delete_unique_identity_reducer::DeleteUniqueIdentityArgs { i: i.clone() }) } + Reducer::DeleteUniqueOptionBool { b } => { + __sats::bsatn::to_vec(&delete_unique_option_bool_reducer::DeleteUniqueOptionBoolArgs { b: b.clone() }) + } + Reducer::DeleteUniqueOptionConnectionId { a } => __sats::bsatn::to_vec( + &delete_unique_option_connection_id_reducer::DeleteUniqueOptionConnectionIdArgs { a: a.clone() }, + ), + Reducer::DeleteUniqueOptionI128 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_i_128_reducer::DeleteUniqueOptionI128Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionI16 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_i_16_reducer::DeleteUniqueOptionI16Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionI256 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_i_256_reducer::DeleteUniqueOptionI256Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionI32 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_i_32_reducer::DeleteUniqueOptionI32Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionI64 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_i_64_reducer::DeleteUniqueOptionI64Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionI8 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_i_8_reducer::DeleteUniqueOptionI8Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionIdentity { i } => { + __sats::bsatn::to_vec(&delete_unique_option_identity_reducer::DeleteUniqueOptionIdentityArgs { + i: i.clone(), + }) + } + Reducer::DeleteUniqueOptionString { s } => { + __sats::bsatn::to_vec(&delete_unique_option_string_reducer::DeleteUniqueOptionStringArgs { + s: s.clone(), + }) + } + Reducer::DeleteUniqueOptionU128 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_u_128_reducer::DeleteUniqueOptionU128Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionU16 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_u_16_reducer::DeleteUniqueOptionU16Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionU256 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_u_256_reducer::DeleteUniqueOptionU256Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionU32 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_u_32_reducer::DeleteUniqueOptionU32Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionU64 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_u_64_reducer::DeleteUniqueOptionU64Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionU8 { n } => { + __sats::bsatn::to_vec(&delete_unique_option_u_8_reducer::DeleteUniqueOptionU8Args { n: n.clone() }) + } + Reducer::DeleteUniqueOptionUuid { u } => { + __sats::bsatn::to_vec(&delete_unique_option_uuid_reducer::DeleteUniqueOptionUuidArgs { u: u.clone() }) + } Reducer::DeleteUniqueString { s } => { __sats::bsatn::to_vec(&delete_unique_string_reducer::DeleteUniqueStringArgs { s: s.clone() }) } @@ -2303,6 +3959,108 @@ impl __sdk::Reducer for Reducer { data: data.clone(), }) } + Reducer::InsertUniqueOptionBool { b, data } => { + __sats::bsatn::to_vec(&insert_unique_option_bool_reducer::InsertUniqueOptionBoolArgs { + b: b.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionConnectionId { a, data } => __sats::bsatn::to_vec( + &insert_unique_option_connection_id_reducer::InsertUniqueOptionConnectionIdArgs { + a: a.clone(), + data: data.clone(), + }, + ), + Reducer::InsertUniqueOptionI128 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_i_128_reducer::InsertUniqueOptionI128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionI16 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_i_16_reducer::InsertUniqueOptionI16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionI256 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_i_256_reducer::InsertUniqueOptionI256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionI32 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_i_32_reducer::InsertUniqueOptionI32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionI64 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_i_64_reducer::InsertUniqueOptionI64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionI8 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_i_8_reducer::InsertUniqueOptionI8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionIdentity { i, data } => { + __sats::bsatn::to_vec(&insert_unique_option_identity_reducer::InsertUniqueOptionIdentityArgs { + i: i.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionString { s, data } => { + __sats::bsatn::to_vec(&insert_unique_option_string_reducer::InsertUniqueOptionStringArgs { + s: s.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionU128 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_u_128_reducer::InsertUniqueOptionU128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionU16 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_u_16_reducer::InsertUniqueOptionU16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionU256 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_u_256_reducer::InsertUniqueOptionU256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionU32 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_u_32_reducer::InsertUniqueOptionU32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionU64 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_u_64_reducer::InsertUniqueOptionU64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionU8 { n, data } => { + __sats::bsatn::to_vec(&insert_unique_option_u_8_reducer::InsertUniqueOptionU8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::InsertUniqueOptionUuid { u, data } => { + __sats::bsatn::to_vec(&insert_unique_option_uuid_reducer::InsertUniqueOptionUuidArgs { + u: u.clone(), + data: data.clone(), + }) + } Reducer::InsertUniqueString { s, data } => { __sats::bsatn::to_vec(&insert_unique_string_reducer::InsertUniqueStringArgs { s: s.clone(), @@ -2595,6 +4353,108 @@ impl __sdk::Reducer for Reducer { data: data.clone(), }) } + Reducer::UpdateUniqueOptionBool { b, data } => { + __sats::bsatn::to_vec(&update_unique_option_bool_reducer::UpdateUniqueOptionBoolArgs { + b: b.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionConnectionId { a, data } => __sats::bsatn::to_vec( + &update_unique_option_connection_id_reducer::UpdateUniqueOptionConnectionIdArgs { + a: a.clone(), + data: data.clone(), + }, + ), + Reducer::UpdateUniqueOptionI128 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_i_128_reducer::UpdateUniqueOptionI128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionI16 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_i_16_reducer::UpdateUniqueOptionI16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionI256 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_i_256_reducer::UpdateUniqueOptionI256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionI32 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_i_32_reducer::UpdateUniqueOptionI32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionI64 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_i_64_reducer::UpdateUniqueOptionI64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionI8 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_i_8_reducer::UpdateUniqueOptionI8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionIdentity { i, data } => { + __sats::bsatn::to_vec(&update_unique_option_identity_reducer::UpdateUniqueOptionIdentityArgs { + i: i.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionString { s, data } => { + __sats::bsatn::to_vec(&update_unique_option_string_reducer::UpdateUniqueOptionStringArgs { + s: s.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionU128 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_u_128_reducer::UpdateUniqueOptionU128Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionU16 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_u_16_reducer::UpdateUniqueOptionU16Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionU256 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_u_256_reducer::UpdateUniqueOptionU256Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionU32 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_u_32_reducer::UpdateUniqueOptionU32Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionU64 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_u_64_reducer::UpdateUniqueOptionU64Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionU8 { n, data } => { + __sats::bsatn::to_vec(&update_unique_option_u_8_reducer::UpdateUniqueOptionU8Args { + n: n.clone(), + data: data.clone(), + }) + } + Reducer::UpdateUniqueOptionUuid { u, data } => { + __sats::bsatn::to_vec(&update_unique_option_uuid_reducer::UpdateUniqueOptionUuidArgs { + u: u.clone(), + data: data.clone(), + }) + } Reducer::UpdateUniqueString { s, data } => { __sats::bsatn::to_vec(&update_unique_string_reducer::UpdateUniqueStringArgs { s: s.clone(), @@ -2726,6 +4586,23 @@ pub struct DbUpdate { unique_i_64: __sdk::TableUpdate, unique_i_8: __sdk::TableUpdate, unique_identity: __sdk::TableUpdate, + unique_option_bool: __sdk::TableUpdate, + unique_option_connection_id: __sdk::TableUpdate, + unique_option_i_128: __sdk::TableUpdate, + unique_option_i_16: __sdk::TableUpdate, + unique_option_i_256: __sdk::TableUpdate, + unique_option_i_32: __sdk::TableUpdate, + unique_option_i_64: __sdk::TableUpdate, + unique_option_i_8: __sdk::TableUpdate, + unique_option_identity: __sdk::TableUpdate, + unique_option_string: __sdk::TableUpdate, + unique_option_u_128: __sdk::TableUpdate, + unique_option_u_16: __sdk::TableUpdate, + unique_option_u_256: __sdk::TableUpdate, + unique_option_u_32: __sdk::TableUpdate, + unique_option_u_64: __sdk::TableUpdate, + unique_option_u_8: __sdk::TableUpdate, + unique_option_uuid: __sdk::TableUpdate, unique_string: __sdk::TableUpdate, unique_u_128: __sdk::TableUpdate, unique_u_16: __sdk::TableUpdate, @@ -2987,6 +4864,57 @@ impl TryFrom<__ws::v2::TransactionUpdate> for DbUpdate { "unique_identity" => db_update .unique_identity .append(unique_identity_table::parse_table_update(table_update)?), + "unique_option_bool" => db_update + .unique_option_bool + .append(unique_option_bool_table::parse_table_update(table_update)?), + "unique_option_connection_id" => db_update + .unique_option_connection_id + .append(unique_option_connection_id_table::parse_table_update(table_update)?), + "unique_option_i_128" => db_update + .unique_option_i_128 + .append(unique_option_i_128_table::parse_table_update(table_update)?), + "unique_option_i_16" => db_update + .unique_option_i_16 + .append(unique_option_i_16_table::parse_table_update(table_update)?), + "unique_option_i_256" => db_update + .unique_option_i_256 + .append(unique_option_i_256_table::parse_table_update(table_update)?), + "unique_option_i_32" => db_update + .unique_option_i_32 + .append(unique_option_i_32_table::parse_table_update(table_update)?), + "unique_option_i_64" => db_update + .unique_option_i_64 + .append(unique_option_i_64_table::parse_table_update(table_update)?), + "unique_option_i_8" => db_update + .unique_option_i_8 + .append(unique_option_i_8_table::parse_table_update(table_update)?), + "unique_option_identity" => db_update + .unique_option_identity + .append(unique_option_identity_table::parse_table_update(table_update)?), + "unique_option_string" => db_update + .unique_option_string + .append(unique_option_string_table::parse_table_update(table_update)?), + "unique_option_u_128" => db_update + .unique_option_u_128 + .append(unique_option_u_128_table::parse_table_update(table_update)?), + "unique_option_u_16" => db_update + .unique_option_u_16 + .append(unique_option_u_16_table::parse_table_update(table_update)?), + "unique_option_u_256" => db_update + .unique_option_u_256 + .append(unique_option_u_256_table::parse_table_update(table_update)?), + "unique_option_u_32" => db_update + .unique_option_u_32 + .append(unique_option_u_32_table::parse_table_update(table_update)?), + "unique_option_u_64" => db_update + .unique_option_u_64 + .append(unique_option_u_64_table::parse_table_update(table_update)?), + "unique_option_u_8" => db_update + .unique_option_u_8 + .append(unique_option_u_8_table::parse_table_update(table_update)?), + "unique_option_uuid" => db_update + .unique_option_uuid + .append(unique_option_uuid_table::parse_table_update(table_update)?), "unique_string" => db_update .unique_string .append(unique_string_table::parse_table_update(table_update)?), @@ -3244,6 +5172,42 @@ impl __sdk::DbUpdate for DbUpdate { diff.unique_i_64 = cache.apply_diff_to_table::("unique_i_64", &self.unique_i_64); diff.unique_i_8 = cache.apply_diff_to_table::("unique_i_8", &self.unique_i_8); diff.unique_identity = cache.apply_diff_to_table::("unique_identity", &self.unique_identity); + diff.unique_option_bool = + cache.apply_diff_to_table::("unique_option_bool", &self.unique_option_bool); + diff.unique_option_connection_id = cache.apply_diff_to_table::( + "unique_option_connection_id", + &self.unique_option_connection_id, + ); + diff.unique_option_i_128 = + cache.apply_diff_to_table::("unique_option_i_128", &self.unique_option_i_128); + diff.unique_option_i_16 = + cache.apply_diff_to_table::("unique_option_i_16", &self.unique_option_i_16); + diff.unique_option_i_256 = + cache.apply_diff_to_table::("unique_option_i_256", &self.unique_option_i_256); + diff.unique_option_i_32 = + cache.apply_diff_to_table::("unique_option_i_32", &self.unique_option_i_32); + diff.unique_option_i_64 = + cache.apply_diff_to_table::("unique_option_i_64", &self.unique_option_i_64); + diff.unique_option_i_8 = + cache.apply_diff_to_table::("unique_option_i_8", &self.unique_option_i_8); + diff.unique_option_identity = + cache.apply_diff_to_table::("unique_option_identity", &self.unique_option_identity); + diff.unique_option_string = + cache.apply_diff_to_table::("unique_option_string", &self.unique_option_string); + diff.unique_option_u_128 = + cache.apply_diff_to_table::("unique_option_u_128", &self.unique_option_u_128); + diff.unique_option_u_16 = + cache.apply_diff_to_table::("unique_option_u_16", &self.unique_option_u_16); + diff.unique_option_u_256 = + cache.apply_diff_to_table::("unique_option_u_256", &self.unique_option_u_256); + diff.unique_option_u_32 = + cache.apply_diff_to_table::("unique_option_u_32", &self.unique_option_u_32); + diff.unique_option_u_64 = + cache.apply_diff_to_table::("unique_option_u_64", &self.unique_option_u_64); + diff.unique_option_u_8 = + cache.apply_diff_to_table::("unique_option_u_8", &self.unique_option_u_8); + diff.unique_option_uuid = + cache.apply_diff_to_table::("unique_option_uuid", &self.unique_option_uuid); diff.unique_string = cache.apply_diff_to_table::("unique_string", &self.unique_string); diff.unique_u_128 = cache.apply_diff_to_table::("unique_u_128", &self.unique_u_128); diff.unique_u_16 = cache.apply_diff_to_table::("unique_u_16", &self.unique_u_16); @@ -3516,6 +5480,57 @@ impl __sdk::DbUpdate for DbUpdate { "unique_identity" => db_update .unique_identity .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_bool" => db_update + .unique_option_bool + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_connection_id" => db_update + .unique_option_connection_id + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_i_128" => db_update + .unique_option_i_128 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_i_16" => db_update + .unique_option_i_16 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_i_256" => db_update + .unique_option_i_256 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_i_32" => db_update + .unique_option_i_32 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_i_64" => db_update + .unique_option_i_64 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_i_8" => db_update + .unique_option_i_8 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_identity" => db_update + .unique_option_identity + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_string" => db_update + .unique_option_string + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_u_128" => db_update + .unique_option_u_128 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_u_16" => db_update + .unique_option_u_16 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_u_256" => db_update + .unique_option_u_256 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_u_32" => db_update + .unique_option_u_32 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_u_64" => db_update + .unique_option_u_64 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_u_8" => db_update + .unique_option_u_8 + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), + "unique_option_uuid" => db_update + .unique_option_uuid + .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), "unique_string" => db_update .unique_string .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?), @@ -3854,6 +5869,57 @@ impl __sdk::DbUpdate for DbUpdate { "unique_identity" => db_update .unique_identity .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_bool" => db_update + .unique_option_bool + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_connection_id" => db_update + .unique_option_connection_id + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_i_128" => db_update + .unique_option_i_128 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_i_16" => db_update + .unique_option_i_16 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_i_256" => db_update + .unique_option_i_256 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_i_32" => db_update + .unique_option_i_32 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_i_64" => db_update + .unique_option_i_64 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_i_8" => db_update + .unique_option_i_8 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_identity" => db_update + .unique_option_identity + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_string" => db_update + .unique_option_string + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_u_128" => db_update + .unique_option_u_128 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_u_16" => db_update + .unique_option_u_16 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_u_256" => db_update + .unique_option_u_256 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_u_32" => db_update + .unique_option_u_32 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_u_64" => db_update + .unique_option_u_64 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_u_8" => db_update + .unique_option_u_8 + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), + "unique_option_uuid" => db_update + .unique_option_uuid + .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), "unique_string" => db_update .unique_string .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?), @@ -4046,6 +6112,23 @@ pub struct AppliedDiff<'r> { unique_i_64: __sdk::TableAppliedDiff<'r, UniqueI64>, unique_i_8: __sdk::TableAppliedDiff<'r, UniqueI8>, unique_identity: __sdk::TableAppliedDiff<'r, UniqueIdentity>, + unique_option_bool: __sdk::TableAppliedDiff<'r, UniqueOptionBool>, + unique_option_connection_id: __sdk::TableAppliedDiff<'r, UniqueOptionConnectionId>, + unique_option_i_128: __sdk::TableAppliedDiff<'r, UniqueOptionI128>, + unique_option_i_16: __sdk::TableAppliedDiff<'r, UniqueOptionI16>, + unique_option_i_256: __sdk::TableAppliedDiff<'r, UniqueOptionI256>, + unique_option_i_32: __sdk::TableAppliedDiff<'r, UniqueOptionI32>, + unique_option_i_64: __sdk::TableAppliedDiff<'r, UniqueOptionI64>, + unique_option_i_8: __sdk::TableAppliedDiff<'r, UniqueOptionI8>, + unique_option_identity: __sdk::TableAppliedDiff<'r, UniqueOptionIdentity>, + unique_option_string: __sdk::TableAppliedDiff<'r, UniqueOptionString>, + unique_option_u_128: __sdk::TableAppliedDiff<'r, UniqueOptionU128>, + unique_option_u_16: __sdk::TableAppliedDiff<'r, UniqueOptionU16>, + unique_option_u_256: __sdk::TableAppliedDiff<'r, UniqueOptionU256>, + unique_option_u_32: __sdk::TableAppliedDiff<'r, UniqueOptionU32>, + unique_option_u_64: __sdk::TableAppliedDiff<'r, UniqueOptionU64>, + unique_option_u_8: __sdk::TableAppliedDiff<'r, UniqueOptionU8>, + unique_option_uuid: __sdk::TableAppliedDiff<'r, UniqueOptionUuid>, unique_string: __sdk::TableAppliedDiff<'r, UniqueString>, unique_u_128: __sdk::TableAppliedDiff<'r, UniqueU128>, unique_u_16: __sdk::TableAppliedDiff<'r, UniqueU16>, @@ -4208,6 +6291,51 @@ impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> { callbacks.invoke_table_row_callbacks::("unique_i_64", &self.unique_i_64, event); callbacks.invoke_table_row_callbacks::("unique_i_8", &self.unique_i_8, event); callbacks.invoke_table_row_callbacks::("unique_identity", &self.unique_identity, event); + callbacks.invoke_table_row_callbacks::("unique_option_bool", &self.unique_option_bool, event); + callbacks.invoke_table_row_callbacks::( + "unique_option_connection_id", + &self.unique_option_connection_id, + event, + ); + callbacks.invoke_table_row_callbacks::( + "unique_option_i_128", + &self.unique_option_i_128, + event, + ); + callbacks.invoke_table_row_callbacks::("unique_option_i_16", &self.unique_option_i_16, event); + callbacks.invoke_table_row_callbacks::( + "unique_option_i_256", + &self.unique_option_i_256, + event, + ); + callbacks.invoke_table_row_callbacks::("unique_option_i_32", &self.unique_option_i_32, event); + callbacks.invoke_table_row_callbacks::("unique_option_i_64", &self.unique_option_i_64, event); + callbacks.invoke_table_row_callbacks::("unique_option_i_8", &self.unique_option_i_8, event); + callbacks.invoke_table_row_callbacks::( + "unique_option_identity", + &self.unique_option_identity, + event, + ); + callbacks.invoke_table_row_callbacks::( + "unique_option_string", + &self.unique_option_string, + event, + ); + callbacks.invoke_table_row_callbacks::( + "unique_option_u_128", + &self.unique_option_u_128, + event, + ); + callbacks.invoke_table_row_callbacks::("unique_option_u_16", &self.unique_option_u_16, event); + callbacks.invoke_table_row_callbacks::( + "unique_option_u_256", + &self.unique_option_u_256, + event, + ); + callbacks.invoke_table_row_callbacks::("unique_option_u_32", &self.unique_option_u_32, event); + callbacks.invoke_table_row_callbacks::("unique_option_u_64", &self.unique_option_u_64, event); + callbacks.invoke_table_row_callbacks::("unique_option_u_8", &self.unique_option_u_8, event); + callbacks.invoke_table_row_callbacks::("unique_option_uuid", &self.unique_option_uuid, event); callbacks.invoke_table_row_callbacks::("unique_string", &self.unique_string, event); callbacks.invoke_table_row_callbacks::("unique_u_128", &self.unique_u_128, event); callbacks.invoke_table_row_callbacks::("unique_u_16", &self.unique_u_16, event); @@ -4986,6 +7114,23 @@ impl __sdk::SpacetimeModule for RemoteModule { unique_i_64_table::register_table(client_cache); unique_i_8_table::register_table(client_cache); unique_identity_table::register_table(client_cache); + unique_option_bool_table::register_table(client_cache); + unique_option_connection_id_table::register_table(client_cache); + unique_option_i_128_table::register_table(client_cache); + unique_option_i_16_table::register_table(client_cache); + unique_option_i_256_table::register_table(client_cache); + unique_option_i_32_table::register_table(client_cache); + unique_option_i_64_table::register_table(client_cache); + unique_option_i_8_table::register_table(client_cache); + unique_option_identity_table::register_table(client_cache); + unique_option_string_table::register_table(client_cache); + unique_option_u_128_table::register_table(client_cache); + unique_option_u_16_table::register_table(client_cache); + unique_option_u_256_table::register_table(client_cache); + unique_option_u_32_table::register_table(client_cache); + unique_option_u_64_table::register_table(client_cache); + unique_option_u_8_table::register_table(client_cache); + unique_option_uuid_table::register_table(client_cache); unique_string_table::register_table(client_cache); unique_u_128_table::register_table(client_cache); unique_u_16_table::register_table(client_cache); @@ -5097,6 +7242,23 @@ impl __sdk::SpacetimeModule for RemoteModule { "unique_i_64", "unique_i_8", "unique_identity", + "unique_option_bool", + "unique_option_connection_id", + "unique_option_i_128", + "unique_option_i_16", + "unique_option_i_256", + "unique_option_i_32", + "unique_option_i_64", + "unique_option_i_8", + "unique_option_identity", + "unique_option_string", + "unique_option_u_128", + "unique_option_u_16", + "unique_option_u_256", + "unique_option_u_32", + "unique_option_u_64", + "unique_option_u_8", + "unique_option_uuid", "unique_string", "unique_u_128", "unique_u_16", diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_uuid_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_uuid_table.rs index 2e72f521768..76244aee9b7 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_uuid_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_uuid_table.rs @@ -95,9 +95,40 @@ impl<'ctx> __sdk::TableWithPrimaryKey for PkUuidTableHandle<'ctx> { } } +/// Access to the `u` unique index on the table `pk_uuid`, +/// which allows point queries on the field of the same name +/// via the [`PkUuidUUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.pk_uuid().u().find(...)`. +pub struct PkUuidUUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> PkUuidTableHandle<'ctx> { + /// Get a handle on the `u` unique index on the table `pk_uuid`. + pub fn u(&self) -> PkUuidUUnique<'ctx> { + PkUuidUUnique { + imp: self.imp.get_unique_constraint::<__sdk::Uuid>("u"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> PkUuidUUnique<'ctx> { + /// Find the subscribed row whose `u` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &__sdk::Uuid) -> Option { + self.imp.find(col_val) + } +} + #[doc(hidden)] pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { let _table = client_cache.get_or_make_table::("pk_uuid"); + _table.add_unique_constraint::<__sdk::Uuid>("u", |row| &row.u); } #[doc(hidden)] diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_bool_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_bool_table.rs new file mode 100644 index 00000000000..9f5af31c433 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_bool_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_bool_type::UniqueOptionBool; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_bool`. +/// +/// Obtain a handle from the [`UniqueOptionBoolTableAccess::unique_option_bool`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_bool()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_bool().on_insert(...)`. +pub struct UniqueOptionBoolTableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_bool`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionBoolTableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionBoolTableHandle`], which mediates access to the table `unique_option_bool`. + fn unique_option_bool(&self) -> UniqueOptionBoolTableHandle<'_>; +} + +impl UniqueOptionBoolTableAccess for super::RemoteTables { + fn unique_option_bool(&self) -> UniqueOptionBoolTableHandle<'_> { + UniqueOptionBoolTableHandle { + imp: self.imp.get_table::("unique_option_bool"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionBoolInsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionBoolDeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionBoolTableHandle<'ctx> { + type Row = UniqueOptionBool; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionBoolInsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionBoolInsertCallbackId { + UniqueOptionBoolInsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionBoolInsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionBoolDeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionBoolDeleteCallbackId { + UniqueOptionBoolDeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionBoolDeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `b` unique index on the table `unique_option_bool`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionBoolBUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_bool().b().find(...)`. +pub struct UniqueOptionBoolBUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionBoolTableHandle<'ctx> { + /// Get a handle on the `b` unique index on the table `unique_option_bool`. + pub fn b(&self) -> UniqueOptionBoolBUnique<'ctx> { + UniqueOptionBoolBUnique { + imp: self.imp.get_unique_constraint::>("b"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionBoolBUnique<'ctx> { + /// Find the subscribed row whose `b` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_bool"); + _table.add_unique_constraint::>("b", |row| &row.b); +} + +#[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 `UniqueOptionBool`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_boolQueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionBool`. + fn unique_option_bool(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_boolQueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_bool(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_bool") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_bool_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_bool_type.rs new file mode 100644 index 00000000000..7d6974655e4 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_bool_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionBool { + pub b: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionBool { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionBool`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionBoolCols { + pub b: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionBool { + type Cols = UniqueOptionBoolCols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionBoolCols { + b: __sdk::__query_builder::Col::new(table_name, "b"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionBool`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionBoolIxCols { + pub b: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionBool { + type IxCols = UniqueOptionBoolIxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionBoolIxCols { + b: __sdk::__query_builder::IxCol::new(table_name, "b"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionBool {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_connection_id_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_connection_id_table.rs new file mode 100644 index 00000000000..9e7f78b940b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_connection_id_table.rs @@ -0,0 +1,144 @@ +// 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::unique_option_connection_id_type::UniqueOptionConnectionId; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_connection_id`. +/// +/// Obtain a handle from the [`UniqueOptionConnectionIdTableAccess::unique_option_connection_id`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_connection_id()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_connection_id().on_insert(...)`. +pub struct UniqueOptionConnectionIdTableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_connection_id`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionConnectionIdTableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionConnectionIdTableHandle`], which mediates access to the table `unique_option_connection_id`. + fn unique_option_connection_id(&self) -> UniqueOptionConnectionIdTableHandle<'_>; +} + +impl UniqueOptionConnectionIdTableAccess for super::RemoteTables { + fn unique_option_connection_id(&self) -> UniqueOptionConnectionIdTableHandle<'_> { + UniqueOptionConnectionIdTableHandle { + imp: self + .imp + .get_table::("unique_option_connection_id"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionConnectionIdInsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionConnectionIdDeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionConnectionIdTableHandle<'ctx> { + type Row = UniqueOptionConnectionId; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionConnectionIdInsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionConnectionIdInsertCallbackId { + UniqueOptionConnectionIdInsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionConnectionIdInsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionConnectionIdDeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionConnectionIdDeleteCallbackId { + UniqueOptionConnectionIdDeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionConnectionIdDeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `a` unique index on the table `unique_option_connection_id`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionConnectionIdAUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_connection_id().a().find(...)`. +pub struct UniqueOptionConnectionIdAUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionConnectionIdTableHandle<'ctx> { + /// Get a handle on the `a` unique index on the table `unique_option_connection_id`. + pub fn a(&self) -> UniqueOptionConnectionIdAUnique<'ctx> { + UniqueOptionConnectionIdAUnique { + imp: self.imp.get_unique_constraint::>("a"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionConnectionIdAUnique<'ctx> { + /// Find the subscribed row whose `a` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option<__sdk::ConnectionId>) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_connection_id"); + _table.add_unique_constraint::>("a", |row| &row.a); +} + +#[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 `UniqueOptionConnectionId`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_connection_idQueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionConnectionId`. + fn unique_option_connection_id(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_connection_idQueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_connection_id(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_connection_id") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_connection_id_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_connection_id_type.rs new file mode 100644 index 00000000000..7ced6f3e42b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_connection_id_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionConnectionId { + pub a: Option<__sdk::ConnectionId>, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionConnectionId { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionConnectionId`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionConnectionIdCols { + pub a: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionConnectionId { + type Cols = UniqueOptionConnectionIdCols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionConnectionIdCols { + a: __sdk::__query_builder::Col::new(table_name, "a"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionConnectionId`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionConnectionIdIxCols { + pub a: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionConnectionId { + type IxCols = UniqueOptionConnectionIdIxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionConnectionIdIxCols { + a: __sdk::__query_builder::IxCol::new(table_name, "a"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionConnectionId {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_128_table.rs new file mode 100644 index 00000000000..3badb7401b1 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_128_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_i_128_type::UniqueOptionI128; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_i_128`. +/// +/// Obtain a handle from the [`UniqueOptionI128TableAccess::unique_option_i_128`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_i_128()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_128().on_insert(...)`. +pub struct UniqueOptionI128TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_i_128`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionI128TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionI128TableHandle`], which mediates access to the table `unique_option_i_128`. + fn unique_option_i_128(&self) -> UniqueOptionI128TableHandle<'_>; +} + +impl UniqueOptionI128TableAccess for super::RemoteTables { + fn unique_option_i_128(&self) -> UniqueOptionI128TableHandle<'_> { + UniqueOptionI128TableHandle { + imp: self.imp.get_table::("unique_option_i_128"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionI128InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionI128DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionI128TableHandle<'ctx> { + type Row = UniqueOptionI128; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionI128InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI128InsertCallbackId { + UniqueOptionI128InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionI128InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionI128DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI128DeleteCallbackId { + UniqueOptionI128DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionI128DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_i_128`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionI128NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_128().n().find(...)`. +pub struct UniqueOptionI128NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionI128TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_i_128`. + pub fn n(&self) -> UniqueOptionI128NUnique<'ctx> { + UniqueOptionI128NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionI128NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_i_128"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionI128`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_i_128QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionI128`. + fn unique_option_i_128(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_i_128QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_i_128(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_i_128") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_128_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_128_type.rs new file mode 100644 index 00000000000..2ce31e4cafa --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_128_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionI128 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionI128 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionI128`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionI128Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionI128 { + type Cols = UniqueOptionI128Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionI128Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionI128`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionI128IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionI128 { + type IxCols = UniqueOptionI128IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionI128IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionI128 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_16_table.rs new file mode 100644 index 00000000000..39222ffec24 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_16_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_i_16_type::UniqueOptionI16; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_i_16`. +/// +/// Obtain a handle from the [`UniqueOptionI16TableAccess::unique_option_i_16`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_i_16()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_16().on_insert(...)`. +pub struct UniqueOptionI16TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_i_16`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionI16TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionI16TableHandle`], which mediates access to the table `unique_option_i_16`. + fn unique_option_i_16(&self) -> UniqueOptionI16TableHandle<'_>; +} + +impl UniqueOptionI16TableAccess for super::RemoteTables { + fn unique_option_i_16(&self) -> UniqueOptionI16TableHandle<'_> { + UniqueOptionI16TableHandle { + imp: self.imp.get_table::("unique_option_i_16"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionI16InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionI16DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionI16TableHandle<'ctx> { + type Row = UniqueOptionI16; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionI16InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI16InsertCallbackId { + UniqueOptionI16InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionI16InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionI16DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI16DeleteCallbackId { + UniqueOptionI16DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionI16DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_i_16`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionI16NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_16().n().find(...)`. +pub struct UniqueOptionI16NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionI16TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_i_16`. + pub fn n(&self) -> UniqueOptionI16NUnique<'ctx> { + UniqueOptionI16NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionI16NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_i_16"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionI16`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_i_16QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionI16`. + fn unique_option_i_16(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_i_16QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_i_16(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_i_16") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_16_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_16_type.rs new file mode 100644 index 00000000000..f50d1c9fa61 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_16_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionI16 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionI16 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionI16`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionI16Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionI16 { + type Cols = UniqueOptionI16Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionI16Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionI16`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionI16IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionI16 { + type IxCols = UniqueOptionI16IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionI16IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionI16 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_256_table.rs new file mode 100644 index 00000000000..e8bc5c0894e --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_256_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_i_256_type::UniqueOptionI256; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_i_256`. +/// +/// Obtain a handle from the [`UniqueOptionI256TableAccess::unique_option_i_256`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_i_256()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_256().on_insert(...)`. +pub struct UniqueOptionI256TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_i_256`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionI256TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionI256TableHandle`], which mediates access to the table `unique_option_i_256`. + fn unique_option_i_256(&self) -> UniqueOptionI256TableHandle<'_>; +} + +impl UniqueOptionI256TableAccess for super::RemoteTables { + fn unique_option_i_256(&self) -> UniqueOptionI256TableHandle<'_> { + UniqueOptionI256TableHandle { + imp: self.imp.get_table::("unique_option_i_256"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionI256InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionI256DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionI256TableHandle<'ctx> { + type Row = UniqueOptionI256; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionI256InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI256InsertCallbackId { + UniqueOptionI256InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionI256InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionI256DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI256DeleteCallbackId { + UniqueOptionI256DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionI256DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_i_256`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionI256NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_256().n().find(...)`. +pub struct UniqueOptionI256NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionI256TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_i_256`. + pub fn n(&self) -> UniqueOptionI256NUnique<'ctx> { + UniqueOptionI256NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionI256NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option<__sats::i256>) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_i_256"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionI256`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_i_256QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionI256`. + fn unique_option_i_256(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_i_256QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_i_256(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_i_256") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_256_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_256_type.rs new file mode 100644 index 00000000000..28201b7e659 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_256_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionI256 { + pub n: Option<__sats::i256>, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionI256 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionI256`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionI256Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionI256 { + type Cols = UniqueOptionI256Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionI256Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionI256`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionI256IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionI256 { + type IxCols = UniqueOptionI256IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionI256IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionI256 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_32_table.rs new file mode 100644 index 00000000000..8771fafb5a1 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_32_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_i_32_type::UniqueOptionI32; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_i_32`. +/// +/// Obtain a handle from the [`UniqueOptionI32TableAccess::unique_option_i_32`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_i_32()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_32().on_insert(...)`. +pub struct UniqueOptionI32TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_i_32`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionI32TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionI32TableHandle`], which mediates access to the table `unique_option_i_32`. + fn unique_option_i_32(&self) -> UniqueOptionI32TableHandle<'_>; +} + +impl UniqueOptionI32TableAccess for super::RemoteTables { + fn unique_option_i_32(&self) -> UniqueOptionI32TableHandle<'_> { + UniqueOptionI32TableHandle { + imp: self.imp.get_table::("unique_option_i_32"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionI32InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionI32DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionI32TableHandle<'ctx> { + type Row = UniqueOptionI32; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionI32InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI32InsertCallbackId { + UniqueOptionI32InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionI32InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionI32DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI32DeleteCallbackId { + UniqueOptionI32DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionI32DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_i_32`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionI32NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_32().n().find(...)`. +pub struct UniqueOptionI32NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionI32TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_i_32`. + pub fn n(&self) -> UniqueOptionI32NUnique<'ctx> { + UniqueOptionI32NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionI32NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_i_32"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionI32`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_i_32QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionI32`. + fn unique_option_i_32(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_i_32QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_i_32(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_i_32") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_32_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_32_type.rs new file mode 100644 index 00000000000..7dbaa0e0ae2 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_32_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionI32 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionI32 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionI32`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionI32Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionI32 { + type Cols = UniqueOptionI32Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionI32Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionI32`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionI32IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionI32 { + type IxCols = UniqueOptionI32IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionI32IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionI32 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_64_table.rs new file mode 100644 index 00000000000..5c4a5918603 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_64_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_i_64_type::UniqueOptionI64; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_i_64`. +/// +/// Obtain a handle from the [`UniqueOptionI64TableAccess::unique_option_i_64`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_i_64()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_64().on_insert(...)`. +pub struct UniqueOptionI64TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_i_64`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionI64TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionI64TableHandle`], which mediates access to the table `unique_option_i_64`. + fn unique_option_i_64(&self) -> UniqueOptionI64TableHandle<'_>; +} + +impl UniqueOptionI64TableAccess for super::RemoteTables { + fn unique_option_i_64(&self) -> UniqueOptionI64TableHandle<'_> { + UniqueOptionI64TableHandle { + imp: self.imp.get_table::("unique_option_i_64"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionI64InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionI64DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionI64TableHandle<'ctx> { + type Row = UniqueOptionI64; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionI64InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI64InsertCallbackId { + UniqueOptionI64InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionI64InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionI64DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI64DeleteCallbackId { + UniqueOptionI64DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionI64DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_i_64`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionI64NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_64().n().find(...)`. +pub struct UniqueOptionI64NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionI64TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_i_64`. + pub fn n(&self) -> UniqueOptionI64NUnique<'ctx> { + UniqueOptionI64NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionI64NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_i_64"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionI64`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_i_64QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionI64`. + fn unique_option_i_64(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_i_64QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_i_64(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_i_64") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_64_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_64_type.rs new file mode 100644 index 00000000000..cf553b6714f --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_64_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionI64 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionI64 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionI64`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionI64Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionI64 { + type Cols = UniqueOptionI64Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionI64Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionI64`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionI64IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionI64 { + type IxCols = UniqueOptionI64IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionI64IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionI64 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_8_table.rs new file mode 100644 index 00000000000..63ba685ff5d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_8_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_i_8_type::UniqueOptionI8; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_i_8`. +/// +/// Obtain a handle from the [`UniqueOptionI8TableAccess::unique_option_i_8`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_i_8()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_8().on_insert(...)`. +pub struct UniqueOptionI8TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_i_8`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionI8TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionI8TableHandle`], which mediates access to the table `unique_option_i_8`. + fn unique_option_i_8(&self) -> UniqueOptionI8TableHandle<'_>; +} + +impl UniqueOptionI8TableAccess for super::RemoteTables { + fn unique_option_i_8(&self) -> UniqueOptionI8TableHandle<'_> { + UniqueOptionI8TableHandle { + imp: self.imp.get_table::("unique_option_i_8"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionI8InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionI8DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionI8TableHandle<'ctx> { + type Row = UniqueOptionI8; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionI8InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI8InsertCallbackId { + UniqueOptionI8InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionI8InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionI8DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionI8DeleteCallbackId { + UniqueOptionI8DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionI8DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_i_8`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionI8NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_i_8().n().find(...)`. +pub struct UniqueOptionI8NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionI8TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_i_8`. + pub fn n(&self) -> UniqueOptionI8NUnique<'ctx> { + UniqueOptionI8NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionI8NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_i_8"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionI8`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_i_8QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionI8`. + fn unique_option_i_8(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_i_8QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_i_8(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_i_8") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_8_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_8_type.rs new file mode 100644 index 00000000000..bdaef090ac2 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_i_8_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionI8 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionI8 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionI8`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionI8Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionI8 { + type Cols = UniqueOptionI8Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionI8Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionI8`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionI8IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionI8 { + type IxCols = UniqueOptionI8IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionI8IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionI8 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_identity_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_identity_table.rs new file mode 100644 index 00000000000..f273e41a2fb --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_identity_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_identity_type::UniqueOptionIdentity; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_identity`. +/// +/// Obtain a handle from the [`UniqueOptionIdentityTableAccess::unique_option_identity`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_identity()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_identity().on_insert(...)`. +pub struct UniqueOptionIdentityTableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_identity`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionIdentityTableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionIdentityTableHandle`], which mediates access to the table `unique_option_identity`. + fn unique_option_identity(&self) -> UniqueOptionIdentityTableHandle<'_>; +} + +impl UniqueOptionIdentityTableAccess for super::RemoteTables { + fn unique_option_identity(&self) -> UniqueOptionIdentityTableHandle<'_> { + UniqueOptionIdentityTableHandle { + imp: self.imp.get_table::("unique_option_identity"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionIdentityInsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionIdentityDeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionIdentityTableHandle<'ctx> { + type Row = UniqueOptionIdentity; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionIdentityInsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionIdentityInsertCallbackId { + UniqueOptionIdentityInsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionIdentityInsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionIdentityDeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionIdentityDeleteCallbackId { + UniqueOptionIdentityDeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionIdentityDeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `i` unique index on the table `unique_option_identity`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionIdentityIUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_identity().i().find(...)`. +pub struct UniqueOptionIdentityIUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionIdentityTableHandle<'ctx> { + /// Get a handle on the `i` unique index on the table `unique_option_identity`. + pub fn i(&self) -> UniqueOptionIdentityIUnique<'ctx> { + UniqueOptionIdentityIUnique { + imp: self.imp.get_unique_constraint::>("i"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionIdentityIUnique<'ctx> { + /// Find the subscribed row whose `i` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option<__sdk::Identity>) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_identity"); + _table.add_unique_constraint::>("i", |row| &row.i); +} + +#[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 `UniqueOptionIdentity`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_identityQueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionIdentity`. + fn unique_option_identity(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_identityQueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_identity(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_identity") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_identity_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_identity_type.rs new file mode 100644 index 00000000000..496813e772b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_identity_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionIdentity { + pub i: Option<__sdk::Identity>, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionIdentity { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionIdentity`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionIdentityCols { + pub i: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionIdentity { + type Cols = UniqueOptionIdentityCols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionIdentityCols { + i: __sdk::__query_builder::Col::new(table_name, "i"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionIdentity`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionIdentityIxCols { + pub i: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionIdentity { + type IxCols = UniqueOptionIdentityIxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionIdentityIxCols { + i: __sdk::__query_builder::IxCol::new(table_name, "i"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionIdentity {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_string_table.rs new file mode 100644 index 00000000000..6bb8b64349b --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_string_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_string_type::UniqueOptionString; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_string`. +/// +/// Obtain a handle from the [`UniqueOptionStringTableAccess::unique_option_string`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_string()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_string().on_insert(...)`. +pub struct UniqueOptionStringTableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_string`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionStringTableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionStringTableHandle`], which mediates access to the table `unique_option_string`. + fn unique_option_string(&self) -> UniqueOptionStringTableHandle<'_>; +} + +impl UniqueOptionStringTableAccess for super::RemoteTables { + fn unique_option_string(&self) -> UniqueOptionStringTableHandle<'_> { + UniqueOptionStringTableHandle { + imp: self.imp.get_table::("unique_option_string"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionStringInsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionStringDeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionStringTableHandle<'ctx> { + type Row = UniqueOptionString; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionStringInsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionStringInsertCallbackId { + UniqueOptionStringInsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionStringInsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionStringDeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionStringDeleteCallbackId { + UniqueOptionStringDeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionStringDeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `s` unique index on the table `unique_option_string`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionStringSUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_string().s().find(...)`. +pub struct UniqueOptionStringSUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionStringTableHandle<'ctx> { + /// Get a handle on the `s` unique index on the table `unique_option_string`. + pub fn s(&self) -> UniqueOptionStringSUnique<'ctx> { + UniqueOptionStringSUnique { + imp: self.imp.get_unique_constraint::>("s"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionStringSUnique<'ctx> { + /// Find the subscribed row whose `s` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_string"); + _table.add_unique_constraint::>("s", |row| &row.s); +} + +#[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 `UniqueOptionString`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_stringQueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionString`. + fn unique_option_string(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_stringQueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_string(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_string") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_string_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_string_type.rs new file mode 100644 index 00000000000..f5b60a12e51 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_string_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionString { + pub s: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionString { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionString`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionStringCols { + pub s: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionString { + type Cols = UniqueOptionStringCols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionStringCols { + s: __sdk::__query_builder::Col::new(table_name, "s"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionString`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionStringIxCols { + pub s: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionString { + type IxCols = UniqueOptionStringIxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionStringIxCols { + s: __sdk::__query_builder::IxCol::new(table_name, "s"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionString {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_128_table.rs new file mode 100644 index 00000000000..b7dd3ab2a65 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_128_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_u_128_type::UniqueOptionU128; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_u_128`. +/// +/// Obtain a handle from the [`UniqueOptionU128TableAccess::unique_option_u_128`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_u_128()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_128().on_insert(...)`. +pub struct UniqueOptionU128TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_u_128`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionU128TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionU128TableHandle`], which mediates access to the table `unique_option_u_128`. + fn unique_option_u_128(&self) -> UniqueOptionU128TableHandle<'_>; +} + +impl UniqueOptionU128TableAccess for super::RemoteTables { + fn unique_option_u_128(&self) -> UniqueOptionU128TableHandle<'_> { + UniqueOptionU128TableHandle { + imp: self.imp.get_table::("unique_option_u_128"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionU128InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionU128DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionU128TableHandle<'ctx> { + type Row = UniqueOptionU128; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionU128InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU128InsertCallbackId { + UniqueOptionU128InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionU128InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionU128DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU128DeleteCallbackId { + UniqueOptionU128DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionU128DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_u_128`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionU128NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_128().n().find(...)`. +pub struct UniqueOptionU128NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionU128TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_u_128`. + pub fn n(&self) -> UniqueOptionU128NUnique<'ctx> { + UniqueOptionU128NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionU128NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_u_128"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionU128`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_u_128QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionU128`. + fn unique_option_u_128(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_u_128QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_u_128(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_u_128") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_128_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_128_type.rs new file mode 100644 index 00000000000..f431301b896 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_128_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionU128 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionU128 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionU128`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionU128Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionU128 { + type Cols = UniqueOptionU128Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionU128Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionU128`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionU128IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionU128 { + type IxCols = UniqueOptionU128IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionU128IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionU128 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_16_table.rs new file mode 100644 index 00000000000..c591fedf70d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_16_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_u_16_type::UniqueOptionU16; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_u_16`. +/// +/// Obtain a handle from the [`UniqueOptionU16TableAccess::unique_option_u_16`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_u_16()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_16().on_insert(...)`. +pub struct UniqueOptionU16TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_u_16`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionU16TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionU16TableHandle`], which mediates access to the table `unique_option_u_16`. + fn unique_option_u_16(&self) -> UniqueOptionU16TableHandle<'_>; +} + +impl UniqueOptionU16TableAccess for super::RemoteTables { + fn unique_option_u_16(&self) -> UniqueOptionU16TableHandle<'_> { + UniqueOptionU16TableHandle { + imp: self.imp.get_table::("unique_option_u_16"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionU16InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionU16DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionU16TableHandle<'ctx> { + type Row = UniqueOptionU16; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionU16InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU16InsertCallbackId { + UniqueOptionU16InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionU16InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionU16DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU16DeleteCallbackId { + UniqueOptionU16DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionU16DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_u_16`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionU16NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_16().n().find(...)`. +pub struct UniqueOptionU16NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionU16TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_u_16`. + pub fn n(&self) -> UniqueOptionU16NUnique<'ctx> { + UniqueOptionU16NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionU16NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_u_16"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionU16`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_u_16QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionU16`. + fn unique_option_u_16(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_u_16QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_u_16(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_u_16") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_16_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_16_type.rs new file mode 100644 index 00000000000..12fd80c358f --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_16_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionU16 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionU16 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionU16`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionU16Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionU16 { + type Cols = UniqueOptionU16Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionU16Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionU16`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionU16IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionU16 { + type IxCols = UniqueOptionU16IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionU16IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionU16 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_256_table.rs new file mode 100644 index 00000000000..ed9a250ee73 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_256_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_u_256_type::UniqueOptionU256; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_u_256`. +/// +/// Obtain a handle from the [`UniqueOptionU256TableAccess::unique_option_u_256`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_u_256()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_256().on_insert(...)`. +pub struct UniqueOptionU256TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_u_256`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionU256TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionU256TableHandle`], which mediates access to the table `unique_option_u_256`. + fn unique_option_u_256(&self) -> UniqueOptionU256TableHandle<'_>; +} + +impl UniqueOptionU256TableAccess for super::RemoteTables { + fn unique_option_u_256(&self) -> UniqueOptionU256TableHandle<'_> { + UniqueOptionU256TableHandle { + imp: self.imp.get_table::("unique_option_u_256"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionU256InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionU256DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionU256TableHandle<'ctx> { + type Row = UniqueOptionU256; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionU256InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU256InsertCallbackId { + UniqueOptionU256InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionU256InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionU256DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU256DeleteCallbackId { + UniqueOptionU256DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionU256DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_u_256`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionU256NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_256().n().find(...)`. +pub struct UniqueOptionU256NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionU256TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_u_256`. + pub fn n(&self) -> UniqueOptionU256NUnique<'ctx> { + UniqueOptionU256NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionU256NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option<__sats::u256>) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_u_256"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionU256`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_u_256QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionU256`. + fn unique_option_u_256(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_u_256QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_u_256(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_u_256") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_256_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_256_type.rs new file mode 100644 index 00000000000..61c85990299 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_256_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionU256 { + pub n: Option<__sats::u256>, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionU256 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionU256`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionU256Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionU256 { + type Cols = UniqueOptionU256Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionU256Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionU256`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionU256IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionU256 { + type IxCols = UniqueOptionU256IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionU256IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionU256 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_32_table.rs new file mode 100644 index 00000000000..95883329d04 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_32_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_u_32_type::UniqueOptionU32; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_u_32`. +/// +/// Obtain a handle from the [`UniqueOptionU32TableAccess::unique_option_u_32`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_u_32()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_32().on_insert(...)`. +pub struct UniqueOptionU32TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_u_32`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionU32TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionU32TableHandle`], which mediates access to the table `unique_option_u_32`. + fn unique_option_u_32(&self) -> UniqueOptionU32TableHandle<'_>; +} + +impl UniqueOptionU32TableAccess for super::RemoteTables { + fn unique_option_u_32(&self) -> UniqueOptionU32TableHandle<'_> { + UniqueOptionU32TableHandle { + imp: self.imp.get_table::("unique_option_u_32"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionU32InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionU32DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionU32TableHandle<'ctx> { + type Row = UniqueOptionU32; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionU32InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU32InsertCallbackId { + UniqueOptionU32InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionU32InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionU32DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU32DeleteCallbackId { + UniqueOptionU32DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionU32DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_u_32`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionU32NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_32().n().find(...)`. +pub struct UniqueOptionU32NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionU32TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_u_32`. + pub fn n(&self) -> UniqueOptionU32NUnique<'ctx> { + UniqueOptionU32NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionU32NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_u_32"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionU32`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_u_32QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionU32`. + fn unique_option_u_32(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_u_32QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_u_32(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_u_32") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_32_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_32_type.rs new file mode 100644 index 00000000000..2d2a9c66867 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_32_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionU32 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionU32 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionU32`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionU32Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionU32 { + type Cols = UniqueOptionU32Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionU32Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionU32`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionU32IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionU32 { + type IxCols = UniqueOptionU32IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionU32IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionU32 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_64_table.rs new file mode 100644 index 00000000000..c395b036b84 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_64_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_u_64_type::UniqueOptionU64; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_u_64`. +/// +/// Obtain a handle from the [`UniqueOptionU64TableAccess::unique_option_u_64`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_u_64()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_64().on_insert(...)`. +pub struct UniqueOptionU64TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_u_64`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionU64TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionU64TableHandle`], which mediates access to the table `unique_option_u_64`. + fn unique_option_u_64(&self) -> UniqueOptionU64TableHandle<'_>; +} + +impl UniqueOptionU64TableAccess for super::RemoteTables { + fn unique_option_u_64(&self) -> UniqueOptionU64TableHandle<'_> { + UniqueOptionU64TableHandle { + imp: self.imp.get_table::("unique_option_u_64"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionU64InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionU64DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionU64TableHandle<'ctx> { + type Row = UniqueOptionU64; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionU64InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU64InsertCallbackId { + UniqueOptionU64InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionU64InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionU64DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU64DeleteCallbackId { + UniqueOptionU64DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionU64DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_u_64`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionU64NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_64().n().find(...)`. +pub struct UniqueOptionU64NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionU64TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_u_64`. + pub fn n(&self) -> UniqueOptionU64NUnique<'ctx> { + UniqueOptionU64NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionU64NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_u_64"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionU64`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_u_64QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionU64`. + fn unique_option_u_64(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_u_64QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_u_64(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_u_64") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_64_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_64_type.rs new file mode 100644 index 00000000000..54e0c344e5d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_64_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionU64 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionU64 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionU64`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionU64Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionU64 { + type Cols = UniqueOptionU64Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionU64Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionU64`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionU64IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionU64 { + type IxCols = UniqueOptionU64IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionU64IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionU64 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_8_table.rs new file mode 100644 index 00000000000..54e92bbbb84 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_8_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_u_8_type::UniqueOptionU8; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_u_8`. +/// +/// Obtain a handle from the [`UniqueOptionU8TableAccess::unique_option_u_8`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_u_8()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_8().on_insert(...)`. +pub struct UniqueOptionU8TableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_u_8`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionU8TableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionU8TableHandle`], which mediates access to the table `unique_option_u_8`. + fn unique_option_u_8(&self) -> UniqueOptionU8TableHandle<'_>; +} + +impl UniqueOptionU8TableAccess for super::RemoteTables { + fn unique_option_u_8(&self) -> UniqueOptionU8TableHandle<'_> { + UniqueOptionU8TableHandle { + imp: self.imp.get_table::("unique_option_u_8"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionU8InsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionU8DeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionU8TableHandle<'ctx> { + type Row = UniqueOptionU8; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionU8InsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU8InsertCallbackId { + UniqueOptionU8InsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionU8InsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionU8DeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionU8DeleteCallbackId { + UniqueOptionU8DeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionU8DeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `n` unique index on the table `unique_option_u_8`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionU8NUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_u_8().n().find(...)`. +pub struct UniqueOptionU8NUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionU8TableHandle<'ctx> { + /// Get a handle on the `n` unique index on the table `unique_option_u_8`. + pub fn n(&self) -> UniqueOptionU8NUnique<'ctx> { + UniqueOptionU8NUnique { + imp: self.imp.get_unique_constraint::>("n"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionU8NUnique<'ctx> { + /// Find the subscribed row whose `n` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_u_8"); + _table.add_unique_constraint::>("n", |row| &row.n); +} + +#[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 `UniqueOptionU8`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_u_8QueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionU8`. + fn unique_option_u_8(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_u_8QueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_u_8(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_u_8") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_8_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_8_type.rs new file mode 100644 index 00000000000..df674cead17 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_u_8_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionU8 { + pub n: Option, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionU8 { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionU8`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionU8Cols { + pub n: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionU8 { + type Cols = UniqueOptionU8Cols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionU8Cols { + n: __sdk::__query_builder::Col::new(table_name, "n"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionU8`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionU8IxCols { + pub n: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionU8 { + type IxCols = UniqueOptionU8IxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionU8IxCols { + n: __sdk::__query_builder::IxCol::new(table_name, "n"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionU8 {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_uuid_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_uuid_table.rs new file mode 100644 index 00000000000..cb22de808ea --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_uuid_table.rs @@ -0,0 +1,142 @@ +// 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::unique_option_uuid_type::UniqueOptionUuid; +use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws}; + +/// Table handle for the table `unique_option_uuid`. +/// +/// Obtain a handle from the [`UniqueOptionUuidTableAccess::unique_option_uuid`] method on [`super::RemoteTables`], +/// like `ctx.db.unique_option_uuid()`. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_uuid().on_insert(...)`. +pub struct UniqueOptionUuidTableHandle<'ctx> { + imp: __sdk::TableHandle, + ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the table `unique_option_uuid`. +/// +/// Implemented for [`super::RemoteTables`]. +pub trait UniqueOptionUuidTableAccess { + #[allow(non_snake_case)] + /// Obtain a [`UniqueOptionUuidTableHandle`], which mediates access to the table `unique_option_uuid`. + fn unique_option_uuid(&self) -> UniqueOptionUuidTableHandle<'_>; +} + +impl UniqueOptionUuidTableAccess for super::RemoteTables { + fn unique_option_uuid(&self) -> UniqueOptionUuidTableHandle<'_> { + UniqueOptionUuidTableHandle { + imp: self.imp.get_table::("unique_option_uuid"), + ctx: std::marker::PhantomData, + } + } +} + +pub struct UniqueOptionUuidInsertCallbackId(__sdk::CallbackId); +pub struct UniqueOptionUuidDeleteCallbackId(__sdk::CallbackId); + +impl<'ctx> __sdk::Table for UniqueOptionUuidTableHandle<'ctx> { + type Row = UniqueOptionUuid; + type EventContext = super::EventContext; + + fn count(&self) -> u64 { + self.imp.count() + } + fn iter(&self) -> impl Iterator + '_ { + self.imp.iter() + } + + type InsertCallbackId = UniqueOptionUuidInsertCallbackId; + + fn on_insert( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionUuidInsertCallbackId { + UniqueOptionUuidInsertCallbackId(self.imp.on_insert(Box::new(callback))) + } + + fn remove_on_insert(&self, callback: UniqueOptionUuidInsertCallbackId) { + self.imp.remove_on_insert(callback.0) + } + + type DeleteCallbackId = UniqueOptionUuidDeleteCallbackId; + + fn on_delete( + &self, + callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static, + ) -> UniqueOptionUuidDeleteCallbackId { + UniqueOptionUuidDeleteCallbackId(self.imp.on_delete(Box::new(callback))) + } + + fn remove_on_delete(&self, callback: UniqueOptionUuidDeleteCallbackId) { + self.imp.remove_on_delete(callback.0) + } +} + +/// Access to the `u` unique index on the table `unique_option_uuid`, +/// which allows point queries on the field of the same name +/// via the [`UniqueOptionUuidUUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_option_uuid().u().find(...)`. +pub struct UniqueOptionUuidUUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle>, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueOptionUuidTableHandle<'ctx> { + /// Get a handle on the `u` unique index on the table `unique_option_uuid`. + pub fn u(&self) -> UniqueOptionUuidUUnique<'ctx> { + UniqueOptionUuidUUnique { + imp: self.imp.get_unique_constraint::>("u"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueOptionUuidUUnique<'ctx> { + /// Find the subscribed row whose `u` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &Option<__sdk::Uuid>) -> Option { + self.imp.find(col_val) + } +} + +#[doc(hidden)] +pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { + let _table = client_cache.get_or_make_table::("unique_option_uuid"); + _table.add_unique_constraint::>("u", |row| &row.u); +} + +#[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 `UniqueOptionUuid`. +/// +/// Implemented for [`__sdk::QueryTableAccessor`]. +pub trait unique_option_uuidQueryTableAccess { + #[allow(non_snake_case)] + /// Get a query builder for the table `UniqueOptionUuid`. + fn unique_option_uuid(&self) -> __sdk::__query_builder::Table; +} + +impl unique_option_uuidQueryTableAccess for __sdk::QueryTableAccessor { + fn unique_option_uuid(&self) -> __sdk::__query_builder::Table { + __sdk::__query_builder::Table::new("unique_option_uuid") + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_option_uuid_type.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_option_uuid_type.rs new file mode 100644 index 00000000000..6659efbf84c --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_option_uuid_type.rs @@ -0,0 +1,52 @@ +// 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 struct UniqueOptionUuid { + pub u: Option<__sdk::Uuid>, + pub data: i32, +} + +impl __sdk::InModule for UniqueOptionUuid { + type Module = super::RemoteModule; +} + +/// Column accessor struct for the table `UniqueOptionUuid`. +/// +/// Provides typed access to columns for query building. +pub struct UniqueOptionUuidCols { + pub u: __sdk::__query_builder::Col>, + pub data: __sdk::__query_builder::Col, +} + +impl __sdk::__query_builder::HasCols for UniqueOptionUuid { + type Cols = UniqueOptionUuidCols; + fn cols(table_name: &'static str) -> Self::Cols { + UniqueOptionUuidCols { + u: __sdk::__query_builder::Col::new(table_name, "u"), + data: __sdk::__query_builder::Col::new(table_name, "data"), + } + } +} + +/// Indexed column accessor struct for the table `UniqueOptionUuid`. +/// +/// Provides typed access to indexed columns for query building. +pub struct UniqueOptionUuidIxCols { + pub u: __sdk::__query_builder::IxCol>, +} + +impl __sdk::__query_builder::HasIxCols for UniqueOptionUuid { + type IxCols = UniqueOptionUuidIxCols; + fn ix_cols(table_name: &'static str) -> Self::IxCols { + UniqueOptionUuidIxCols { + u: __sdk::__query_builder::IxCol::new(table_name, "u"), + } + } +} + +impl __sdk::__query_builder::CanBeLookupTable for UniqueOptionUuid {} diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_uuid_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_uuid_table.rs index 771136825a1..2fecc6da61a 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_uuid_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_uuid_table.rs @@ -78,9 +78,40 @@ impl<'ctx> __sdk::Table for UniqueUuidTableHandle<'ctx> { } } +/// Access to the `u` unique index on the table `unique_uuid`, +/// which allows point queries on the field of the same name +/// via the [`UniqueUuidUUnique::find`] method. +/// +/// Users are encouraged not to explicitly reference this type, +/// but to directly chain method calls, +/// like `ctx.db.unique_uuid().u().find(...)`. +pub struct UniqueUuidUUnique<'ctx> { + imp: __sdk::UniqueConstraintHandle, + phantom: std::marker::PhantomData<&'ctx super::RemoteTables>, +} + +impl<'ctx> UniqueUuidTableHandle<'ctx> { + /// Get a handle on the `u` unique index on the table `unique_uuid`. + pub fn u(&self) -> UniqueUuidUUnique<'ctx> { + UniqueUuidUUnique { + imp: self.imp.get_unique_constraint::<__sdk::Uuid>("u"), + phantom: std::marker::PhantomData, + } + } +} + +impl<'ctx> UniqueUuidUUnique<'ctx> { + /// Find the subscribed row whose `u` column value is equal to `col_val`, + /// if such a row is present in the client cache. + pub fn find(&self, col_val: &__sdk::Uuid) -> Option { + self.imp.find(col_val) + } +} + #[doc(hidden)] pub(super) fn register_table(client_cache: &mut __sdk::ClientCache) { let _table = client_cache.get_or_make_table::("unique_uuid"); + _table.add_unique_constraint::<__sdk::Uuid>("u", |row| &row.u); } #[doc(hidden)] diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_bool_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_bool_reducer.rs new file mode 100644 index 00000000000..b0cfa37a623 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionBoolArgs { + pub b: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionBoolArgs) -> Self { + Self::UpdateUniqueOptionBool { + b: args.b, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionBoolArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_bool`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_bool { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_bool:update_unique_option_bool_then`] to run a callback after the reducer completes. + fn update_unique_option_bool(&self, b: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_bool_then(b, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_bool_then( + &self, + b: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_bool for super::RemoteReducers { + fn update_unique_option_bool_then( + &self, + b: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionBoolArgs { b, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_connection_id_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_connection_id_reducer.rs new file mode 100644 index 00000000000..16d419cf86d --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionConnectionIdArgs { + pub a: Option<__sdk::ConnectionId>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionConnectionIdArgs) -> Self { + Self::UpdateUniqueOptionConnectionId { + a: args.a, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionConnectionIdArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_connection_id`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_connection_id { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_connection_id:update_unique_option_connection_id_then`] to run a callback after the reducer completes. + fn update_unique_option_connection_id(&self, a: Option<__sdk::ConnectionId>, data: i32) -> __sdk::Result<()> { + self.update_unique_option_connection_id_then(a, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_connection_id_then( + &self, + a: Option<__sdk::ConnectionId>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_connection_id for super::RemoteReducers { + fn update_unique_option_connection_id_then( + &self, + a: Option<__sdk::ConnectionId>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionConnectionIdArgs { a, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_128_reducer.rs new file mode 100644 index 00000000000..814e9246354 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionI128Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionI128Args) -> Self { + Self::UpdateUniqueOptionI128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionI128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_i_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_i_128 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_i_128:update_unique_option_i_128_then`] to run a callback after the reducer completes. + fn update_unique_option_i_128(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_i_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_i_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_i_128 for super::RemoteReducers { + fn update_unique_option_i_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionI128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_16_reducer.rs new file mode 100644 index 00000000000..5f2a6702f16 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionI16Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionI16Args) -> Self { + Self::UpdateUniqueOptionI16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionI16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_i_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_i_16 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_i_16:update_unique_option_i_16_then`] to run a callback after the reducer completes. + fn update_unique_option_i_16(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_i_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_i_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_i_16 for super::RemoteReducers { + fn update_unique_option_i_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionI16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_256_reducer.rs new file mode 100644 index 00000000000..b1fea5f5f88 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionI256Args { + pub n: Option<__sats::i256>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionI256Args) -> Self { + Self::UpdateUniqueOptionI256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionI256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_i_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_i_256 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_i_256:update_unique_option_i_256_then`] to run a callback after the reducer completes. + fn update_unique_option_i_256(&self, n: Option<__sats::i256>, data: i32) -> __sdk::Result<()> { + self.update_unique_option_i_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_i_256_then( + &self, + n: Option<__sats::i256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_i_256 for super::RemoteReducers { + fn update_unique_option_i_256_then( + &self, + n: Option<__sats::i256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionI256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_32_reducer.rs new file mode 100644 index 00000000000..0363aff0dcd --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionI32Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionI32Args) -> Self { + Self::UpdateUniqueOptionI32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionI32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_i_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_i_32 { + /// Request that the remote module invoke the reducer `update_unique_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 [`update_unique_option_i_32:update_unique_option_i_32_then`] to run a callback after the reducer completes. + fn update_unique_option_i_32(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_i_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_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 update_unique_option_i_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_i_32 for super::RemoteReducers { + fn update_unique_option_i_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionI32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_64_reducer.rs new file mode 100644 index 00000000000..b8be863cce0 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionI64Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionI64Args) -> Self { + Self::UpdateUniqueOptionI64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionI64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_i_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_i_64 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_i_64:update_unique_option_i_64_then`] to run a callback after the reducer completes. + fn update_unique_option_i_64(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_i_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_i_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_i_64 for super::RemoteReducers { + fn update_unique_option_i_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionI64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_i_8_reducer.rs new file mode 100644 index 00000000000..76d2a8ba1ae --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionI8Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionI8Args) -> Self { + Self::UpdateUniqueOptionI8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionI8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_i_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_i_8 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_i_8:update_unique_option_i_8_then`] to run a callback after the reducer completes. + fn update_unique_option_i_8(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_i_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_i_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_i_8 for super::RemoteReducers { + fn update_unique_option_i_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionI8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_identity_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_identity_reducer.rs new file mode 100644 index 00000000000..d75df3cd89f --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionIdentityArgs { + pub i: Option<__sdk::Identity>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionIdentityArgs) -> Self { + Self::UpdateUniqueOptionIdentity { + i: args.i, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionIdentityArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_identity`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_identity { + /// Request that the remote module invoke the reducer `update_unique_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 [`update_unique_option_identity:update_unique_option_identity_then`] to run a callback after the reducer completes. + fn update_unique_option_identity(&self, i: Option<__sdk::Identity>, data: i32) -> __sdk::Result<()> { + self.update_unique_option_identity_then(i, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_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 update_unique_option_identity_then( + &self, + i: Option<__sdk::Identity>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_identity for super::RemoteReducers { + fn update_unique_option_identity_then( + &self, + i: Option<__sdk::Identity>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionIdentityArgs { i, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_string_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_string_reducer.rs new file mode 100644 index 00000000000..f63a44071f0 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionStringArgs { + pub s: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionStringArgs) -> Self { + Self::UpdateUniqueOptionString { + s: args.s, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionStringArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_string`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_string { + /// Request that the remote module invoke the reducer `update_unique_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 [`update_unique_option_string:update_unique_option_string_then`] to run a callback after the reducer completes. + fn update_unique_option_string(&self, s: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_string_then(s, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_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 update_unique_option_string_then( + &self, + s: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_string for super::RemoteReducers { + fn update_unique_option_string_then( + &self, + s: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionStringArgs { s, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_128_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_128_reducer.rs new file mode 100644 index 00000000000..ad88b5d848e --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionU128Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionU128Args) -> Self { + Self::UpdateUniqueOptionU128 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionU128Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_u_128`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_u_128 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_u_128:update_unique_option_u_128_then`] to run a callback after the reducer completes. + fn update_unique_option_u_128(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_u_128_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_u_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_u_128 for super::RemoteReducers { + fn update_unique_option_u_128_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionU128Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_16_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_16_reducer.rs new file mode 100644 index 00000000000..d2e5119b935 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionU16Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionU16Args) -> Self { + Self::UpdateUniqueOptionU16 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionU16Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_u_16`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_u_16 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_u_16:update_unique_option_u_16_then`] to run a callback after the reducer completes. + fn update_unique_option_u_16(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_u_16_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_u_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_u_16 for super::RemoteReducers { + fn update_unique_option_u_16_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionU16Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_256_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_256_reducer.rs new file mode 100644 index 00000000000..3d47d52e870 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionU256Args { + pub n: Option<__sats::u256>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionU256Args) -> Self { + Self::UpdateUniqueOptionU256 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionU256Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_u_256`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_u_256 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_u_256:update_unique_option_u_256_then`] to run a callback after the reducer completes. + fn update_unique_option_u_256(&self, n: Option<__sats::u256>, data: i32) -> __sdk::Result<()> { + self.update_unique_option_u_256_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_u_256_then( + &self, + n: Option<__sats::u256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_u_256 for super::RemoteReducers { + fn update_unique_option_u_256_then( + &self, + n: Option<__sats::u256>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionU256Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_32_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_32_reducer.rs new file mode 100644 index 00000000000..4eaefbece40 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionU32Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionU32Args) -> Self { + Self::UpdateUniqueOptionU32 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionU32Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_u_32`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_u_32 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_u_32:update_unique_option_u_32_then`] to run a callback after the reducer completes. + fn update_unique_option_u_32(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_u_32_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_u_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_u_32 for super::RemoteReducers { + fn update_unique_option_u_32_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionU32Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_64_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_64_reducer.rs new file mode 100644 index 00000000000..69406107812 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionU64Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionU64Args) -> Self { + Self::UpdateUniqueOptionU64 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionU64Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_u_64`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_u_64 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_u_64:update_unique_option_u_64_then`] to run a callback after the reducer completes. + fn update_unique_option_u_64(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_u_64_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_u_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_u_64 for super::RemoteReducers { + fn update_unique_option_u_64_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionU64Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_8_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_u_8_reducer.rs new file mode 100644 index 00000000000..fa7a6c1dcfd --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionU8Args { + pub n: Option, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionU8Args) -> Self { + Self::UpdateUniqueOptionU8 { + n: args.n, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionU8Args { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_u_8`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_u_8 { + /// Request that the remote module invoke the reducer `update_unique_option_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 [`update_unique_option_u_8:update_unique_option_u_8_then`] to run a callback after the reducer completes. + fn update_unique_option_u_8(&self, n: Option, data: i32) -> __sdk::Result<()> { + self.update_unique_option_u_8_then(n, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_option_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 update_unique_option_u_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_u_8 for super::RemoteReducers { + fn update_unique_option_u_8_then( + &self, + n: Option, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionU8Args { n, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_uuid_reducer.rs b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_uuid_reducer.rs new file mode 100644 index 00000000000..b14aebe2272 --- /dev/null +++ b/sdks/rust/tests/test-client/src/module_bindings/update_unique_option_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 UpdateUniqueOptionUuidArgs { + pub u: Option<__sdk::Uuid>, + pub data: i32, +} + +impl From for super::Reducer { + fn from(args: UpdateUniqueOptionUuidArgs) -> Self { + Self::UpdateUniqueOptionUuid { + u: args.u, + data: args.data, + } + } +} + +impl __sdk::InModule for UpdateUniqueOptionUuidArgs { + type Module = super::RemoteModule; +} + +#[allow(non_camel_case_types)] +/// Extension trait for access to the reducer `update_unique_option_uuid`. +/// +/// Implemented for [`super::RemoteReducers`]. +pub trait update_unique_option_uuid { + /// Request that the remote module invoke the reducer `update_unique_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 [`update_unique_option_uuid:update_unique_option_uuid_then`] to run a callback after the reducer completes. + fn update_unique_option_uuid(&self, u: Option<__sdk::Uuid>, data: i32) -> __sdk::Result<()> { + self.update_unique_option_uuid_then(u, data, |_, _| {}) + } + + /// Request that the remote module invoke the reducer `update_unique_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 update_unique_option_uuid_then( + &self, + u: Option<__sdk::Uuid>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()>; +} + +impl update_unique_option_uuid for super::RemoteReducers { + fn update_unique_option_uuid_then( + &self, + u: Option<__sdk::Uuid>, + data: i32, + + callback: impl FnOnce(&super::ReducerEventContext, Result, __sdk::InternalError>) + + Send + + 'static, + ) -> __sdk::Result<()> { + self.imp + .invoke_reducer_with_callback(UpdateUniqueOptionUuidArgs { u, data }, callback) + } +} diff --git a/sdks/rust/tests/test-client/src/test_handlers.rs b/sdks/rust/tests/test-client/src/test_handlers.rs index c8b56c978fc..d4bb0ac3e24 100644 --- a/sdks/rust/tests/test-client/src/test_handlers.rs +++ b/sdks/rust/tests/test-client/src/test_handlers.rs @@ -81,6 +81,9 @@ pub async fn dispatch(test: &str, db_name: &str) { "insert-simple-enum" => exec_insert_simple_enum(db_name).await, "insert-enum-with-payload" => exec_insert_enum_with_payload(db_name).await, + "delete-option-some" => exec_delete_option_some(db_name).await, + "delete-option-none" => exec_delete_option_none(db_name).await, + "insert-delete-large-table" => exec_insert_delete_large_table(db_name).await, "insert-primitives-as-strings" => exec_insert_primitives_as_strings(db_name).await, @@ -337,6 +340,23 @@ const SUBSCRIBE_ALL: &[&str] = &[ "SELECT * FROM unique_identity;", "SELECT * FROM unique_connection_id;", "SELECT * FROM unique_uuid;", + "SELECT * FROM unique_option_u_8;", + "SELECT * FROM unique_option_u_16;", + "SELECT * FROM unique_option_u_32;", + "SELECT * FROM unique_option_u_64;", + "SELECT * FROM unique_option_u_128;", + "SELECT * FROM unique_option_u_256;", + "SELECT * FROM unique_option_i_8;", + "SELECT * FROM unique_option_i_16;", + "SELECT * FROM unique_option_i_32;", + "SELECT * FROM unique_option_i_64;", + "SELECT * FROM unique_option_i_128;", + "SELECT * FROM unique_option_i_256;", + "SELECT * FROM unique_option_bool;", + "SELECT * FROM unique_option_string;", + "SELECT * FROM unique_option_identity;", + "SELECT * FROM unique_option_connection_id;", + "SELECT * FROM unique_option_uuid;", "SELECT * FROM pk_u_8;", "SELECT * FROM pk_u_16;", "SELECT * FROM pk_u_32;", @@ -1425,6 +1445,79 @@ async fn exec_insert_enum_with_payload(db_name: &str) { test_counter.wait_for_all().await; } +async fn exec_delete_option_some(db_name: &str) { + let test_counter = TestCounter::new(); + let sub_applied_nothing_result = test_counter.add_test("on_subscription_applied_nothing"); + + let connection = connect_then(db_name, &test_counter, { + let test_counter = test_counter.clone(); + move |ctx| { + subscribe_all_then(ctx, move |ctx| { + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0u8.into()), 0xbeef); + + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some(0i8.into()), 0xbeef); + + insert_then_delete_one::(ctx, &test_counter, Some(false), 0xbeef); + insert_then_delete_one::(ctx, &test_counter, Some("".to_string()), 0xbeef); + + sub_applied_nothing_result(assert_all_tables_empty(ctx)); + }); + } + }) + .await; + + test_counter.wait_for_all().await; + + assert_all_tables_empty(&connection).unwrap(); +} + +async fn exec_delete_option_none(db_name: &str) { + let test_counter = TestCounter::new(); + let sub_applied_nothing_result = test_counter.add_test("on_subscription_applied_nothing"); + + let connection = connect_then(db_name, &test_counter, { + let test_counter = test_counter.clone(); + move |ctx| { + subscribe_all_then(ctx, move |ctx| { + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + + insert_then_delete_one::(ctx, &test_counter, None, 0xbeef); + + sub_applied_nothing_result(assert_all_tables_empty(ctx)); + }); + } + }) + .await; + + test_counter.wait_for_all().await; + + assert_all_tables_empty(&connection).unwrap(); +} + /// This tests that the test machinery itself is functional and can detect failures. async fn exec_should_fail(_db_name: &str) { let test_counter = TestCounter::new(); diff --git a/sdks/rust/tests/test-client/src/unique_test_table.rs b/sdks/rust/tests/test-client/src/unique_test_table.rs index 672565f752e..009945616d3 100644 --- a/sdks/rust/tests/test-client/src/unique_test_table.rs +++ b/sdks/rust/tests/test-client/src/unique_test_table.rs @@ -3,7 +3,7 @@ use spacetimedb_sdk::{i256, u256, ConnectionId, Event, Identity, Table, Uuid}; use std::sync::Arc; use test_counter::TestCounter; -pub trait UniqueTestTable: std::fmt::Debug { +pub trait UniqueTestTable: std::fmt::Debug + Sized { type Key: Clone + Send + Sync + PartialEq + std::fmt::Debug + 'static; fn as_key(&self) -> &Self::Key; @@ -17,6 +17,8 @@ pub trait UniqueTestTable: std::fmt::Debug { fn on_insert(ctx: &impl RemoteDbContext, callback: impl FnMut(&EventContext, &Self) + Send + 'static); fn on_delete(ctx: &impl RemoteDbContext, callback: impl FnMut(&EventContext, &Self) + Send + 'static); + + fn find(ctx: &impl RemoteDbContext, key: &Self::Key) -> Option; } pub fn insert_then_delete_one( @@ -44,6 +46,11 @@ pub fn insert_then_delete_one( "Unexpected Reducer variant {:?}", reducer_event.reducer, ); + anyhow::ensure!( + T::find(ctx, row.as_key()).is_none(), + "Expected row not to be present in client cache during delete event", + ); + Ok(()) }; @@ -68,6 +75,16 @@ pub fn insert_then_delete_one( "Unexpected Reducer variant {:?}", reducer_event.reducer, ); + + let Some(row_from_ctx) = T::find(ctx, row.as_key()) else { + anyhow::bail!("Expected row to be present in client cache during insert event"); + }; + + anyhow::ensure!( + row.as_value() == row_from_ctx.as_value(), + "Expected version of row in client cache to match version passed to on_insert callback" + ); + Ok(()) }; @@ -134,6 +151,10 @@ macro_rules! impl_unique_test_table { fn on_delete(ctx: &impl RemoteDbContext, callback: impl FnMut(&EventContext, &$table) + Send + 'static) { ctx.db().$accessor_method().on_delete(callback); } + + fn find(ctx: &impl RemoteDbContext, key: &Self::Key) -> Option { + ctx.db().$accessor_method().$field_name().find(key) + } } }; ($($table:ident { $($stuff:tt)* })*) => { @@ -302,3 +323,165 @@ impl_unique_test_table! { accessor_method = unique_uuid; } } + +impl_unique_test_table! { + UniqueOptionU8 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_u_8_then; + insert_reducer_event = InsertUniqueOptionU8; + delete_then = delete_unique_option_u_8_then; + delete_reducer_event = DeleteUniqueOptionU8; + accessor_method = unique_option_u_8; + } + UniqueOptionU16 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_u_16_then; + insert_reducer_event = InsertUniqueOptionU16; + delete_then = delete_unique_option_u_16_then; + delete_reducer_event = DeleteUniqueOptionU16; + accessor_method = unique_option_u_16; + } + UniqueOptionU32 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_u_32_then; + insert_reducer_event = InsertUniqueOptionU32; + delete_then = delete_unique_option_u_32_then; + delete_reducer_event = DeleteUniqueOptionU32; + accessor_method = unique_option_u_32; + } + UniqueOptionU64 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_u_64_then; + insert_reducer_event = InsertUniqueOptionU64; + delete_then = delete_unique_option_u_64_then; + delete_reducer_event = DeleteUniqueOptionU64; + accessor_method = unique_option_u_64; + } + UniqueOptionU128 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_u_128_then; + insert_reducer_event = InsertUniqueOptionU128; + delete_then = delete_unique_option_u_128_then; + delete_reducer_event = DeleteUniqueOptionU128; + accessor_method = unique_option_u_128; + } + UniqueOptionU256 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_u_256_then; + insert_reducer_event = InsertUniqueOptionU256; + delete_then = delete_unique_option_u_256_then; + delete_reducer_event = DeleteUniqueOptionU256; + accessor_method = unique_option_u_256; + } + + UniqueOptionI8 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_i_8_then; + insert_reducer_event = InsertUniqueOptionI8; + delete_then = delete_unique_option_i_8_then; + delete_reducer_event = DeleteUniqueOptionI8; + accessor_method = unique_option_i_8; + } + UniqueOptionI16 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_i_16_then; + insert_reducer_event = InsertUniqueOptionI16; + delete_then = delete_unique_option_i_16_then; + delete_reducer_event = DeleteUniqueOptionI16; + accessor_method = unique_option_i_16; + } + UniqueOptionI32 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_i_32_then; + insert_reducer_event = InsertUniqueOptionI32; + delete_then = delete_unique_option_i_32_then; + delete_reducer_event = DeleteUniqueOptionI32; + accessor_method = unique_option_i_32; + } + UniqueOptionI64 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_i_64_then; + insert_reducer_event = InsertUniqueOptionI64; + delete_then = delete_unique_option_i_64_then; + delete_reducer_event = DeleteUniqueOptionI64; + accessor_method = unique_option_i_64; + } + UniqueOptionI128 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_i_128_then; + insert_reducer_event = InsertUniqueOptionI128; + delete_then = delete_unique_option_i_128_then; + delete_reducer_event = DeleteUniqueOptionI128; + accessor_method = unique_option_i_128; + } + UniqueOptionI256 { + Key = Option; + key_field_name = n; + insert_then = insert_unique_option_i_256_then; + insert_reducer_event = InsertUniqueOptionI256; + delete_then = delete_unique_option_i_256_then; + delete_reducer_event = DeleteUniqueOptionI256; + accessor_method = unique_option_i_256; + } + + UniqueOptionBool { + Key = Option; + key_field_name = b; + insert_then = insert_unique_option_bool_then; + insert_reducer_event = InsertUniqueOptionBool; + delete_then = delete_unique_option_bool_then; + delete_reducer_event = DeleteUniqueOptionBool; + accessor_method = unique_option_bool; + } + + UniqueOptionString { + Key = Option; + key_field_name = s; + insert_then = insert_unique_option_string_then; + insert_reducer_event = InsertUniqueOptionString; + delete_then = delete_unique_option_string_then; + delete_reducer_event = DeleteUniqueOptionString; + accessor_method = unique_option_string; + } + + UniqueOptionIdentity { + Key = Option; + key_field_name = i; + insert_then = insert_unique_option_identity_then; + insert_reducer_event = InsertUniqueOptionIdentity; + delete_then = delete_unique_option_identity_then; + delete_reducer_event = DeleteUniqueOptionIdentity; + accessor_method = unique_option_identity; + } + + UniqueOptionConnectionId { + Key = Option; + key_field_name = a; + insert_then = insert_unique_option_connection_id_then; + insert_reducer_event = InsertUniqueOptionConnectionId; + delete_then = delete_unique_option_connection_id_then; + delete_reducer_event = DeleteUniqueOptionConnectionId; + accessor_method = unique_option_connection_id; + } + + UniqueOptionUuid { + Key = Option; + key_field_name = u; + insert_then = insert_unique_option_uuid_then; + insert_reducer_event = InsertUniqueOptionUuid; + delete_then = delete_unique_option_uuid_then; + delete_reducer_event = DeleteUniqueOptionUuid; + accessor_method = unique_option_uuid; + } +} diff --git a/sdks/rust/tests/test.rs b/sdks/rust/tests/test.rs index af7c535824b..7c5b3c13998 100644 --- a/sdks/rust/tests/test.rs +++ b/sdks/rust/tests/test.rs @@ -211,7 +211,7 @@ macro_rules! declare_tests_with_suffix { #[test] fn update_uuid() { - make_test("delete-uuid").run(); + make_test("update-uuid").run(); } #[test] @@ -239,6 +239,16 @@ macro_rules! declare_tests_with_suffix { make_test("insert-option-none").run(); } + #[test] + fn delete_option_some() { + make_test("delete-option-some").run(); + } + + #[test] + fn delete_option_none() { + make_test("delete-option-none").run(); + } + #[test] fn insert_struct() { make_test("insert-struct").run(); diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp index f9344999447..f7d830dc9aa 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp @@ -76,6 +76,23 @@ #include "ModuleBindings/Tables/UniqueI64Table.g.h" #include "ModuleBindings/Tables/UniqueI8Table.g.h" #include "ModuleBindings/Tables/UniqueIdentityTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionBoolTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionI128Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI16Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI256Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI32Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI64Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI8Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionIdentityTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionStringTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionU128Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU16Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU256Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU32Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU64Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU8Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionUuidTable.g.h" #include "ModuleBindings/Tables/UniqueStringTable.g.h" #include "ModuleBindings/Tables/UniqueU128Table.g.h" #include "ModuleBindings/Tables/UniqueU16Table.g.h" @@ -195,6 +212,23 @@ UDbConnection::UDbConnection(const FObjectInitializer& ObjectInitializer) : Supe RegisterTable(TEXT("unique_i_64"), Db->UniqueI64); RegisterTable(TEXT("unique_i_8"), Db->UniqueI8); RegisterTable(TEXT("unique_identity"), Db->UniqueIdentity); + RegisterTable(TEXT("unique_option_bool"), Db->UniqueOptionBool); + RegisterTable(TEXT("unique_option_connection_id"), Db->UniqueOptionConnectionId); + RegisterTable(TEXT("unique_option_i_128"), Db->UniqueOptionI128); + RegisterTable(TEXT("unique_option_i_16"), Db->UniqueOptionI16); + RegisterTable(TEXT("unique_option_i_256"), Db->UniqueOptionI256); + RegisterTable(TEXT("unique_option_i_32"), Db->UniqueOptionI32); + RegisterTable(TEXT("unique_option_i_64"), Db->UniqueOptionI64); + RegisterTable(TEXT("unique_option_i_8"), Db->UniqueOptionI8); + RegisterTable(TEXT("unique_option_identity"), Db->UniqueOptionIdentity); + RegisterTable(TEXT("unique_option_string"), Db->UniqueOptionString); + RegisterTable(TEXT("unique_option_u_128"), Db->UniqueOptionU128); + RegisterTable(TEXT("unique_option_u_16"), Db->UniqueOptionU16); + RegisterTable(TEXT("unique_option_u_256"), Db->UniqueOptionU256); + RegisterTable(TEXT("unique_option_u_32"), Db->UniqueOptionU32); + RegisterTable(TEXT("unique_option_u_64"), Db->UniqueOptionU64); + RegisterTable(TEXT("unique_option_u_8"), Db->UniqueOptionU8); + RegisterTable(TEXT("unique_option_uuid"), Db->UniqueOptionUuid); RegisterTable(TEXT("unique_string"), Db->UniqueString); RegisterTable(TEXT("unique_u_128"), Db->UniqueU128); RegisterTable(TEXT("unique_u_16"), Db->UniqueU16); @@ -336,6 +370,23 @@ void URemoteTables::Initialize() UniqueI64 = NewObject(this); UniqueI8 = NewObject(this); UniqueIdentity = NewObject(this); + UniqueOptionBool = NewObject(this); + UniqueOptionConnectionId = NewObject(this); + UniqueOptionI128 = NewObject(this); + UniqueOptionI16 = NewObject(this); + UniqueOptionI256 = NewObject(this); + UniqueOptionI32 = NewObject(this); + UniqueOptionI64 = NewObject(this); + UniqueOptionI8 = NewObject(this); + UniqueOptionIdentity = NewObject(this); + UniqueOptionString = NewObject(this); + UniqueOptionU128 = NewObject(this); + UniqueOptionU16 = NewObject(this); + UniqueOptionU256 = NewObject(this); + UniqueOptionU32 = NewObject(this); + UniqueOptionU64 = NewObject(this); + UniqueOptionU8 = NewObject(this); + UniqueOptionUuid = NewObject(this); UniqueString = NewObject(this); UniqueU128 = NewObject(this); UniqueU16 = NewObject(this); @@ -446,6 +497,23 @@ void URemoteTables::Initialize() UniqueI64->PostInitialize(); UniqueI8->PostInitialize(); UniqueIdentity->PostInitialize(); + UniqueOptionBool->PostInitialize(); + UniqueOptionConnectionId->PostInitialize(); + UniqueOptionI128->PostInitialize(); + UniqueOptionI16->PostInitialize(); + UniqueOptionI256->PostInitialize(); + UniqueOptionI32->PostInitialize(); + UniqueOptionI64->PostInitialize(); + UniqueOptionI8->PostInitialize(); + UniqueOptionIdentity->PostInitialize(); + UniqueOptionString->PostInitialize(); + UniqueOptionU128->PostInitialize(); + UniqueOptionU16->PostInitialize(); + UniqueOptionU256->PostInitialize(); + UniqueOptionU32->PostInitialize(); + UniqueOptionU64->PostInitialize(); + UniqueOptionU8->PostInitialize(); + UniqueOptionUuid->PostInitialize(); UniqueString->PostInitialize(); UniqueU128->PostInitialize(); UniqueU16->PostInitialize(); @@ -3198,7 +3266,7 @@ bool URemoteReducers::InvokeDeleteAllUniqueIdentityWithArgs(const FReducerEventC return true; } -void URemoteReducers::DeleteAllUniqueString(const FString& S, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data) { if (!Conn) { @@ -3206,45 +3274,45 @@ void URemoteReducers::DeleteAllUniqueString(const FString& S, const int32 Data) return; } - FDeleteAllUniqueStringArgs ReducerArgs(S, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueString(ReducerArgs)); } + FDeleteAllUniqueOptionBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionBool(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueString(const FReducerEventContext& Context, const UDeleteAllUniqueStringReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionBool(const FReducerEventContext& Context, const UDeleteAllUniqueOptionBoolReducer* Args) { - if (!OnDeleteAllUniqueString.IsBound()) + if (!OnDeleteAllUniqueOptionBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionBool")); } return false; } - OnDeleteAllUniqueString.Broadcast(Context, Args->S, Args->Data); + OnDeleteAllUniqueOptionBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueStringArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionBoolArgs& Args) { - if (!OnDeleteAllUniqueString.IsBound()) + if (!OnDeleteAllUniqueOptionBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionBool")); } return false; } - OnDeleteAllUniqueString.Broadcast(Context, Args.S, Args.Data); + OnDeleteAllUniqueOptionBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data) { if (!Conn) { @@ -3252,45 +3320,45 @@ void URemoteReducers::DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const in return; } - FDeleteAllUniqueU128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU128(ReducerArgs)); } + FDeleteAllUniqueOptionConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU128(const FReducerEventContext& Context, const UDeleteAllUniqueU128Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionConnectionId(const FReducerEventContext& Context, const UDeleteAllUniqueOptionConnectionIdReducer* Args) { - if (!OnDeleteAllUniqueU128.IsBound()) + if (!OnDeleteAllUniqueOptionConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionConnectionId")); } return false; } - OnDeleteAllUniqueU128.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU128Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionConnectionIdArgs& Args) { - if (!OnDeleteAllUniqueU128.IsBound()) + if (!OnDeleteAllUniqueOptionConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionConnectionId")); } return false; } - OnDeleteAllUniqueU128.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU16(const uint16 N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data) { if (!Conn) { @@ -3298,45 +3366,45 @@ void URemoteReducers::DeleteAllUniqueU16(const uint16 N, const int32 Data) return; } - FDeleteAllUniqueU16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU16(ReducerArgs)); } + FDeleteAllUniqueOptionI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU16(const FReducerEventContext& Context, const UDeleteAllUniqueU16Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI128(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI128Reducer* Args) { - if (!OnDeleteAllUniqueU16.IsBound()) + if (!OnDeleteAllUniqueOptionI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI128")); } return false; } - OnDeleteAllUniqueU16.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU16Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI128Args& Args) { - if (!OnDeleteAllUniqueU16.IsBound()) + if (!OnDeleteAllUniqueOptionI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI128")); } return false; } - OnDeleteAllUniqueU16.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data) { if (!Conn) { @@ -3344,45 +3412,45 @@ void URemoteReducers::DeleteAllUniqueU256(const FSpacetimeDBUInt256& N, const in return; } - FDeleteAllUniqueU256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU256(ReducerArgs)); } + FDeleteAllUniqueOptionI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI16(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU256(const FReducerEventContext& Context, const UDeleteAllUniqueU256Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI16(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI16Reducer* Args) { - if (!OnDeleteAllUniqueU256.IsBound()) + if (!OnDeleteAllUniqueOptionI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI16")); } return false; } - OnDeleteAllUniqueU256.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU256Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI16Args& Args) { - if (!OnDeleteAllUniqueU256.IsBound()) + if (!OnDeleteAllUniqueOptionI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI16")); } return false; } - OnDeleteAllUniqueU256.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU32(const uint32 N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data) { if (!Conn) { @@ -3390,45 +3458,45 @@ void URemoteReducers::DeleteAllUniqueU32(const uint32 N, const int32 Data) return; } - FDeleteAllUniqueU32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU32(ReducerArgs)); } + FDeleteAllUniqueOptionI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU32(const FReducerEventContext& Context, const UDeleteAllUniqueU32Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI256(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI256Reducer* Args) { - if (!OnDeleteAllUniqueU32.IsBound()) + if (!OnDeleteAllUniqueOptionI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI256")); } return false; } - OnDeleteAllUniqueU32.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU32Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI256Args& Args) { - if (!OnDeleteAllUniqueU32.IsBound()) + if (!OnDeleteAllUniqueOptionI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI256")); } return false; } - OnDeleteAllUniqueU32.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU64(const uint64 N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data) { if (!Conn) { @@ -3436,45 +3504,45 @@ void URemoteReducers::DeleteAllUniqueU64(const uint64 N, const int32 Data) return; } - FDeleteAllUniqueU64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU64(ReducerArgs)); } + FDeleteAllUniqueOptionI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU64(const FReducerEventContext& Context, const UDeleteAllUniqueU64Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI32(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI32Reducer* Args) { - if (!OnDeleteAllUniqueU64.IsBound()) + if (!OnDeleteAllUniqueOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI32")); } return false; } - OnDeleteAllUniqueU64.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU64Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI32Args& Args) { - if (!OnDeleteAllUniqueU64.IsBound()) + if (!OnDeleteAllUniqueOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI32")); } return false; } - OnDeleteAllUniqueU64.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU8(const uint8 N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data) { if (!Conn) { @@ -3482,45 +3550,45 @@ void URemoteReducers::DeleteAllUniqueU8(const uint8 N, const int32 Data) return; } - FDeleteAllUniqueU8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU8(ReducerArgs)); } + FDeleteAllUniqueOptionI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU8(const FReducerEventContext& Context, const UDeleteAllUniqueU8Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI64(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI64Reducer* Args) { - if (!OnDeleteAllUniqueU8.IsBound()) + if (!OnDeleteAllUniqueOptionI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI64")); } return false; } - OnDeleteAllUniqueU8.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU8Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI64Args& Args) { - if (!OnDeleteAllUniqueU8.IsBound()) + if (!OnDeleteAllUniqueOptionI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI64")); } return false; } - OnDeleteAllUniqueU8.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data) { if (!Conn) { @@ -3528,45 +3596,45 @@ void URemoteReducers::DeleteAllUniqueUuid(const FSpacetimeDBUuid& U, const int32 return; } - FDeleteAllUniqueUuidArgs ReducerArgs(U, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueUuid(ReducerArgs)); } + FDeleteAllUniqueOptionI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueUuid(const FReducerEventContext& Context, const UDeleteAllUniqueUuidReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI8(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI8Reducer* Args) { - if (!OnDeleteAllUniqueUuid.IsBound()) + if (!OnDeleteAllUniqueOptionI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI8")); } return false; } - OnDeleteAllUniqueUuid.Broadcast(Context, Args->U, Args->Data); + OnDeleteAllUniqueOptionI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueUuidArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI8Args& Args) { - if (!OnDeleteAllUniqueUuid.IsBound()) + if (!OnDeleteAllUniqueOptionI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI8")); } return false; } - OnDeleteAllUniqueUuid.Broadcast(Context, Args.U, Args.Data); + OnDeleteAllUniqueOptionI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecBool(const TArray& B) +void URemoteReducers::DeleteAllUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data) { if (!Conn) { @@ -3574,45 +3642,45 @@ void URemoteReducers::DeleteAllVecBool(const TArray& B) return; } - FDeleteAllVecBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecBool(ReducerArgs)); } + FDeleteAllUniqueOptionIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecBool(const FReducerEventContext& Context, const UDeleteAllVecBoolReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionIdentity(const FReducerEventContext& Context, const UDeleteAllUniqueOptionIdentityReducer* Args) { - if (!OnDeleteAllVecBool.IsBound()) + if (!OnDeleteAllUniqueOptionIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionIdentity")); } return false; } - OnDeleteAllVecBool.Broadcast(Context, Args->B); + OnDeleteAllUniqueOptionIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecBoolWithArgs(const FReducerEventContext& Context, const FDeleteAllVecBoolArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionIdentityArgs& Args) { - if (!OnDeleteAllVecBool.IsBound()) + if (!OnDeleteAllUniqueOptionIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionIdentity")); } return false; } - OnDeleteAllVecBool.Broadcast(Context, Args.B); + OnDeleteAllUniqueOptionIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::DeleteAllVecByteStruct(const TArray& S) +void URemoteReducers::DeleteAllUniqueOptionString(const FTestClientOptionalString& S, const int32 Data) { if (!Conn) { @@ -3620,45 +3688,45 @@ void URemoteReducers::DeleteAllVecByteStruct(const TArray& S) return; } - FDeleteAllVecByteStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_byte_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecByteStruct(ReducerArgs)); } + FDeleteAllUniqueOptionStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionString(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecByteStruct(const FReducerEventContext& Context, const UDeleteAllVecByteStructReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionString(const FReducerEventContext& Context, const UDeleteAllUniqueOptionStringReducer* Args) { - if (!OnDeleteAllVecByteStruct.IsBound()) + if (!OnDeleteAllUniqueOptionString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionString")); } return false; } - OnDeleteAllVecByteStruct.Broadcast(Context, Args->S); + OnDeleteAllUniqueOptionString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecByteStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecByteStructArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionStringArgs& Args) { - if (!OnDeleteAllVecByteStruct.IsBound()) + if (!OnDeleteAllUniqueOptionString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionString")); } return false; } - OnDeleteAllVecByteStruct.Broadcast(Context, Args.S); + OnDeleteAllUniqueOptionString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::DeleteAllVecEnumWithPayload(const TArray& E) +void URemoteReducers::DeleteAllUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data) { if (!Conn) { @@ -3666,45 +3734,45 @@ void URemoteReducers::DeleteAllVecEnumWithPayload(const TArrayCallReducerTyped(TEXT("delete_all_vec_enum_with_payload"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEnumWithPayload(ReducerArgs)); } + FDeleteAllUniqueOptionU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecEnumWithPayload(const FReducerEventContext& Context, const UDeleteAllVecEnumWithPayloadReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU128(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU128Reducer* Args) { - if (!OnDeleteAllVecEnumWithPayload.IsBound()) + if (!OnDeleteAllUniqueOptionU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU128")); } return false; } - OnDeleteAllVecEnumWithPayload.Broadcast(Context, Args->E); + OnDeleteAllUniqueOptionU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEnumWithPayloadArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU128Args& Args) { - if (!OnDeleteAllVecEnumWithPayload.IsBound()) + if (!OnDeleteAllUniqueOptionU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU128")); } return false; } - OnDeleteAllVecEnumWithPayload.Broadcast(Context, Args.E); + OnDeleteAllUniqueOptionU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecEveryPrimitiveStruct(const TArray& S) +void URemoteReducers::DeleteAllUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data) { if (!Conn) { @@ -3712,45 +3780,45 @@ void URemoteReducers::DeleteAllVecEveryPrimitiveStruct(const TArrayCallReducerTyped(TEXT("delete_all_vec_every_primitive_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEveryPrimitiveStruct(ReducerArgs)); } + FDeleteAllUniqueOptionU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU16(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecEveryPrimitiveStruct(const FReducerEventContext& Context, const UDeleteAllVecEveryPrimitiveStructReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU16(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU16Reducer* Args) { - if (!OnDeleteAllVecEveryPrimitiveStruct.IsBound()) + if (!OnDeleteAllUniqueOptionU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU16")); } return false; } - OnDeleteAllVecEveryPrimitiveStruct.Broadcast(Context, Args->S); + OnDeleteAllUniqueOptionU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEveryPrimitiveStructArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU16Args& Args) { - if (!OnDeleteAllVecEveryPrimitiveStruct.IsBound()) + if (!OnDeleteAllUniqueOptionU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU16")); } return false; } - OnDeleteAllVecEveryPrimitiveStruct.Broadcast(Context, Args.S); + OnDeleteAllUniqueOptionU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecEveryVecStruct(const TArray& S) +void URemoteReducers::DeleteAllUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data) { if (!Conn) { @@ -3758,45 +3826,45 @@ void URemoteReducers::DeleteAllVecEveryVecStruct(const TArrayCallReducerTyped(TEXT("delete_all_vec_every_vec_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEveryVecStruct(ReducerArgs)); } + FDeleteAllUniqueOptionU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecEveryVecStruct(const FReducerEventContext& Context, const UDeleteAllVecEveryVecStructReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU256(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU256Reducer* Args) { - if (!OnDeleteAllVecEveryVecStruct.IsBound()) + if (!OnDeleteAllUniqueOptionU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU256")); } return false; } - OnDeleteAllVecEveryVecStruct.Broadcast(Context, Args->S); + OnDeleteAllUniqueOptionU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecEveryVecStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEveryVecStructArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU256Args& Args) { - if (!OnDeleteAllVecEveryVecStruct.IsBound()) + if (!OnDeleteAllUniqueOptionU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU256")); } return false; } - OnDeleteAllVecEveryVecStruct.Broadcast(Context, Args.S); + OnDeleteAllUniqueOptionU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecF32(const TArray& F) +void URemoteReducers::DeleteAllUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data) { if (!Conn) { @@ -3804,45 +3872,45 @@ void URemoteReducers::DeleteAllVecF32(const TArray& F) return; } - FDeleteAllVecF32Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_f_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecF32(ReducerArgs)); } + FDeleteAllUniqueOptionU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecF32(const FReducerEventContext& Context, const UDeleteAllVecF32Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU32(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU32Reducer* Args) { - if (!OnDeleteAllVecF32.IsBound()) + if (!OnDeleteAllUniqueOptionU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU32")); } return false; } - OnDeleteAllVecF32.Broadcast(Context, Args->F); + OnDeleteAllUniqueOptionU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecF32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecF32Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU32Args& Args) { - if (!OnDeleteAllVecF32.IsBound()) + if (!OnDeleteAllUniqueOptionU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU32")); } return false; } - OnDeleteAllVecF32.Broadcast(Context, Args.F); + OnDeleteAllUniqueOptionU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecF64(const TArray& F) +void URemoteReducers::DeleteAllUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data) { if (!Conn) { @@ -3850,45 +3918,45 @@ void URemoteReducers::DeleteAllVecF64(const TArray& F) return; } - FDeleteAllVecF64Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_f_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecF64(ReducerArgs)); } + FDeleteAllUniqueOptionU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecF64(const FReducerEventContext& Context, const UDeleteAllVecF64Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU64(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU64Reducer* Args) { - if (!OnDeleteAllVecF64.IsBound()) + if (!OnDeleteAllUniqueOptionU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU64")); } return false; } - OnDeleteAllVecF64.Broadcast(Context, Args->F); + OnDeleteAllUniqueOptionU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecF64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecF64Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU64Args& Args) { - if (!OnDeleteAllVecF64.IsBound()) + if (!OnDeleteAllUniqueOptionU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU64")); } return false; } - OnDeleteAllVecF64.Broadcast(Context, Args.F); + OnDeleteAllUniqueOptionU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI128(const TArray& N) +void URemoteReducers::DeleteAllUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data) { if (!Conn) { @@ -3896,45 +3964,45 @@ void URemoteReducers::DeleteAllVecI128(const TArray& N) return; } - FDeleteAllVecI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI128(ReducerArgs)); } + FDeleteAllUniqueOptionU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI128(const FReducerEventContext& Context, const UDeleteAllVecI128Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU8(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU8Reducer* Args) { - if (!OnDeleteAllVecI128.IsBound()) + if (!OnDeleteAllUniqueOptionU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU8")); } return false; } - OnDeleteAllVecI128.Broadcast(Context, Args->N); + OnDeleteAllUniqueOptionU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI128WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI128Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU8Args& Args) { - if (!OnDeleteAllVecI128.IsBound()) + if (!OnDeleteAllUniqueOptionU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU8")); } return false; } - OnDeleteAllVecI128.Broadcast(Context, Args.N); + OnDeleteAllUniqueOptionU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI16(const TArray& N) +void URemoteReducers::DeleteAllUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data) { if (!Conn) { @@ -3942,45 +4010,45 @@ void URemoteReducers::DeleteAllVecI16(const TArray& N) return; } - FDeleteAllVecI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI16(ReducerArgs)); } + FDeleteAllUniqueOptionUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI16(const FReducerEventContext& Context, const UDeleteAllVecI16Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionUuid(const FReducerEventContext& Context, const UDeleteAllUniqueOptionUuidReducer* Args) { - if (!OnDeleteAllVecI16.IsBound()) + if (!OnDeleteAllUniqueOptionUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionUuid")); } return false; } - OnDeleteAllVecI16.Broadcast(Context, Args->N); + OnDeleteAllUniqueOptionUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI16WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI16Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionUuidArgs& Args) { - if (!OnDeleteAllVecI16.IsBound()) + if (!OnDeleteAllUniqueOptionUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionUuid")); } return false; } - OnDeleteAllVecI16.Broadcast(Context, Args.N); + OnDeleteAllUniqueOptionUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI256(const TArray& N) +void URemoteReducers::DeleteAllUniqueString(const FString& S, const int32 Data) { if (!Conn) { @@ -3988,45 +4056,45 @@ void URemoteReducers::DeleteAllVecI256(const TArray& N) return; } - FDeleteAllVecI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI256(ReducerArgs)); } + FDeleteAllUniqueStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueString(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI256(const FReducerEventContext& Context, const UDeleteAllVecI256Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueString(const FReducerEventContext& Context, const UDeleteAllUniqueStringReducer* Args) { - if (!OnDeleteAllVecI256.IsBound()) + if (!OnDeleteAllUniqueString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueString")); } return false; } - OnDeleteAllVecI256.Broadcast(Context, Args->N); + OnDeleteAllUniqueString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI256WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI256Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueStringArgs& Args) { - if (!OnDeleteAllVecI256.IsBound()) + if (!OnDeleteAllUniqueString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueString")); } return false; } - OnDeleteAllVecI256.Broadcast(Context, Args.N); + OnDeleteAllUniqueString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI32(const TArray& N) +void URemoteReducers::DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data) { if (!Conn) { @@ -4034,45 +4102,45 @@ void URemoteReducers::DeleteAllVecI32(const TArray& N) return; } - FDeleteAllVecI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI32(ReducerArgs)); } + FDeleteAllUniqueU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI32(const FReducerEventContext& Context, const UDeleteAllVecI32Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU128(const FReducerEventContext& Context, const UDeleteAllUniqueU128Reducer* Args) { - if (!OnDeleteAllVecI32.IsBound()) + if (!OnDeleteAllUniqueU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU128")); } return false; } - OnDeleteAllVecI32.Broadcast(Context, Args->N); + OnDeleteAllUniqueU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI32Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU128Args& Args) { - if (!OnDeleteAllVecI32.IsBound()) + if (!OnDeleteAllUniqueU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU128")); } return false; } - OnDeleteAllVecI32.Broadcast(Context, Args.N); + OnDeleteAllUniqueU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI64(const TArray& N) +void URemoteReducers::DeleteAllUniqueU16(const uint16 N, const int32 Data) { if (!Conn) { @@ -4080,45 +4148,45 @@ void URemoteReducers::DeleteAllVecI64(const TArray& N) return; } - FDeleteAllVecI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI64(ReducerArgs)); } + FDeleteAllUniqueU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU16(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI64(const FReducerEventContext& Context, const UDeleteAllVecI64Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU16(const FReducerEventContext& Context, const UDeleteAllUniqueU16Reducer* Args) { - if (!OnDeleteAllVecI64.IsBound()) + if (!OnDeleteAllUniqueU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU16")); } return false; } - OnDeleteAllVecI64.Broadcast(Context, Args->N); + OnDeleteAllUniqueU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI64Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU16Args& Args) { - if (!OnDeleteAllVecI64.IsBound()) + if (!OnDeleteAllUniqueU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU16")); } return false; } - OnDeleteAllVecI64.Broadcast(Context, Args.N); + OnDeleteAllUniqueU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI8(const TArray& N) +void URemoteReducers::DeleteAllUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data) { if (!Conn) { @@ -4126,45 +4194,45 @@ void URemoteReducers::DeleteAllVecI8(const TArray& N) return; } - FDeleteAllVecI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI8(ReducerArgs)); } + FDeleteAllUniqueU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI8(const FReducerEventContext& Context, const UDeleteAllVecI8Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU256(const FReducerEventContext& Context, const UDeleteAllUniqueU256Reducer* Args) { - if (!OnDeleteAllVecI8.IsBound()) + if (!OnDeleteAllUniqueU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU256")); } return false; } - OnDeleteAllVecI8.Broadcast(Context, Args->N); + OnDeleteAllUniqueU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI8WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI8Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU256Args& Args) { - if (!OnDeleteAllVecI8.IsBound()) + if (!OnDeleteAllUniqueU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU256")); } return false; } - OnDeleteAllVecI8.Broadcast(Context, Args.N); + OnDeleteAllUniqueU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecIdentity(const TArray& I) +void URemoteReducers::DeleteAllUniqueU32(const uint32 N, const int32 Data) { if (!Conn) { @@ -4172,45 +4240,45 @@ void URemoteReducers::DeleteAllVecIdentity(const TArray& I return; } - FDeleteAllVecIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecIdentity(ReducerArgs)); } + FDeleteAllUniqueU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecIdentity(const FReducerEventContext& Context, const UDeleteAllVecIdentityReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU32(const FReducerEventContext& Context, const UDeleteAllUniqueU32Reducer* Args) { - if (!OnDeleteAllVecIdentity.IsBound()) + if (!OnDeleteAllUniqueU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU32")); } return false; } - OnDeleteAllVecIdentity.Broadcast(Context, Args->I); + OnDeleteAllUniqueU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllVecIdentityArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU32Args& Args) { - if (!OnDeleteAllVecIdentity.IsBound()) + if (!OnDeleteAllUniqueU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU32")); } return false; } - OnDeleteAllVecIdentity.Broadcast(Context, Args.I); + OnDeleteAllUniqueU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecSimpleEnum(const TArray& E) +void URemoteReducers::DeleteAllUniqueU64(const uint64 N, const int32 Data) { if (!Conn) { @@ -4218,45 +4286,45 @@ void URemoteReducers::DeleteAllVecSimpleEnum(const TArray& E) return; } - FDeleteAllVecSimpleEnumArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecSimpleEnum(ReducerArgs)); } + FDeleteAllUniqueU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecSimpleEnum(const FReducerEventContext& Context, const UDeleteAllVecSimpleEnumReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU64(const FReducerEventContext& Context, const UDeleteAllUniqueU64Reducer* Args) { - if (!OnDeleteAllVecSimpleEnum.IsBound()) + if (!OnDeleteAllUniqueU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU64")); } return false; } - OnDeleteAllVecSimpleEnum.Broadcast(Context, Args->E); + OnDeleteAllUniqueU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecSimpleEnumWithArgs(const FReducerEventContext& Context, const FDeleteAllVecSimpleEnumArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU64Args& Args) { - if (!OnDeleteAllVecSimpleEnum.IsBound()) + if (!OnDeleteAllUniqueU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU64")); } return false; } - OnDeleteAllVecSimpleEnum.Broadcast(Context, Args.E); + OnDeleteAllUniqueU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecString(const TArray& S) +void URemoteReducers::DeleteAllUniqueU8(const uint8 N, const int32 Data) { if (!Conn) { @@ -4264,45 +4332,45 @@ void URemoteReducers::DeleteAllVecString(const TArray& S) return; } - FDeleteAllVecStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecString(ReducerArgs)); } + FDeleteAllUniqueU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecString(const FReducerEventContext& Context, const UDeleteAllVecStringReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU8(const FReducerEventContext& Context, const UDeleteAllUniqueU8Reducer* Args) { - if (!OnDeleteAllVecString.IsBound()) + if (!OnDeleteAllUniqueU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU8")); } return false; } - OnDeleteAllVecString.Broadcast(Context, Args->S); + OnDeleteAllUniqueU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecStringWithArgs(const FReducerEventContext& Context, const FDeleteAllVecStringArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU8Args& Args) { - if (!OnDeleteAllVecString.IsBound()) + if (!OnDeleteAllUniqueU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU8")); } return false; } - OnDeleteAllVecString.Broadcast(Context, Args.S); + OnDeleteAllUniqueU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecTimestamp(const TArray& T) +void URemoteReducers::DeleteAllUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data) { if (!Conn) { @@ -4310,45 +4378,45 @@ void URemoteReducers::DeleteAllVecTimestamp(const TArray& return; } - FDeleteAllVecTimestampArgs ReducerArgs(T); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_timestamp"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecTimestamp(ReducerArgs)); } + FDeleteAllUniqueUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecTimestamp(const FReducerEventContext& Context, const UDeleteAllVecTimestampReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueUuid(const FReducerEventContext& Context, const UDeleteAllUniqueUuidReducer* Args) { - if (!OnDeleteAllVecTimestamp.IsBound()) + if (!OnDeleteAllUniqueUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueUuid")); } return false; } - OnDeleteAllVecTimestamp.Broadcast(Context, Args->T); + OnDeleteAllUniqueUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecTimestampWithArgs(const FReducerEventContext& Context, const FDeleteAllVecTimestampArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueUuidArgs& Args) { - if (!OnDeleteAllVecTimestamp.IsBound()) + if (!OnDeleteAllUniqueUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueUuid")); } return false; } - OnDeleteAllVecTimestamp.Broadcast(Context, Args.T); + OnDeleteAllUniqueUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::DeleteAllVecU128(const TArray& N) +void URemoteReducers::DeleteAllVecBool(const TArray& B) { if (!Conn) { @@ -4356,45 +4424,45 @@ void URemoteReducers::DeleteAllVecU128(const TArray& N) return; } - FDeleteAllVecU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU128(ReducerArgs)); } + FDeleteAllVecBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecBool(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU128(const FReducerEventContext& Context, const UDeleteAllVecU128Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecBool(const FReducerEventContext& Context, const UDeleteAllVecBoolReducer* Args) { - if (!OnDeleteAllVecU128.IsBound()) + if (!OnDeleteAllVecBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecBool")); } return false; } - OnDeleteAllVecU128.Broadcast(Context, Args->N); + OnDeleteAllVecBool.Broadcast(Context, Args->B); return true; } -bool URemoteReducers::InvokeDeleteAllVecU128WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU128Args& Args) +bool URemoteReducers::InvokeDeleteAllVecBoolWithArgs(const FReducerEventContext& Context, const FDeleteAllVecBoolArgs& Args) { - if (!OnDeleteAllVecU128.IsBound()) + if (!OnDeleteAllVecBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecBool")); } return false; } - OnDeleteAllVecU128.Broadcast(Context, Args.N); + OnDeleteAllVecBool.Broadcast(Context, Args.B); return true; } -void URemoteReducers::DeleteAllVecU16(const TArray& N) +void URemoteReducers::DeleteAllVecByteStruct(const TArray& S) { if (!Conn) { @@ -4402,45 +4470,45 @@ void URemoteReducers::DeleteAllVecU16(const TArray& N) return; } - FDeleteAllVecU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU16(ReducerArgs)); } + FDeleteAllVecByteStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_byte_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecByteStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU16(const FReducerEventContext& Context, const UDeleteAllVecU16Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecByteStruct(const FReducerEventContext& Context, const UDeleteAllVecByteStructReducer* Args) { - if (!OnDeleteAllVecU16.IsBound()) + if (!OnDeleteAllVecByteStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecByteStruct")); } return false; } - OnDeleteAllVecU16.Broadcast(Context, Args->N); + OnDeleteAllVecByteStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteAllVecU16WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU16Args& Args) +bool URemoteReducers::InvokeDeleteAllVecByteStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecByteStructArgs& Args) { - if (!OnDeleteAllVecU16.IsBound()) + if (!OnDeleteAllVecByteStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecByteStruct")); } return false; } - OnDeleteAllVecU16.Broadcast(Context, Args.N); + OnDeleteAllVecByteStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteAllVecU256(const TArray& N) +void URemoteReducers::DeleteAllVecEnumWithPayload(const TArray& E) { if (!Conn) { @@ -4448,45 +4516,45 @@ void URemoteReducers::DeleteAllVecU256(const TArray& N) return; } - FDeleteAllVecU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU256(ReducerArgs)); } + FDeleteAllVecEnumWithPayloadArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_enum_with_payload"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEnumWithPayload(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU256(const FReducerEventContext& Context, const UDeleteAllVecU256Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecEnumWithPayload(const FReducerEventContext& Context, const UDeleteAllVecEnumWithPayloadReducer* Args) { - if (!OnDeleteAllVecU256.IsBound()) + if (!OnDeleteAllVecEnumWithPayload.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEnumWithPayload")); } return false; } - OnDeleteAllVecU256.Broadcast(Context, Args->N); + OnDeleteAllVecEnumWithPayload.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeDeleteAllVecU256WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU256Args& Args) +bool URemoteReducers::InvokeDeleteAllVecEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEnumWithPayloadArgs& Args) { - if (!OnDeleteAllVecU256.IsBound()) + if (!OnDeleteAllVecEnumWithPayload.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEnumWithPayload")); } return false; } - OnDeleteAllVecU256.Broadcast(Context, Args.N); + OnDeleteAllVecEnumWithPayload.Broadcast(Context, Args.E); return true; } -void URemoteReducers::DeleteAllVecU32(const TArray& N) +void URemoteReducers::DeleteAllVecEveryPrimitiveStruct(const TArray& S) { if (!Conn) { @@ -4494,45 +4562,45 @@ void URemoteReducers::DeleteAllVecU32(const TArray& N) return; } - FDeleteAllVecU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU32(ReducerArgs)); } + FDeleteAllVecEveryPrimitiveStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_every_primitive_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEveryPrimitiveStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU32(const FReducerEventContext& Context, const UDeleteAllVecU32Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecEveryPrimitiveStruct(const FReducerEventContext& Context, const UDeleteAllVecEveryPrimitiveStructReducer* Args) { - if (!OnDeleteAllVecU32.IsBound()) + if (!OnDeleteAllVecEveryPrimitiveStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryPrimitiveStruct")); } return false; } - OnDeleteAllVecU32.Broadcast(Context, Args->N); + OnDeleteAllVecEveryPrimitiveStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteAllVecU32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU32Args& Args) +bool URemoteReducers::InvokeDeleteAllVecEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEveryPrimitiveStructArgs& Args) { - if (!OnDeleteAllVecU32.IsBound()) + if (!OnDeleteAllVecEveryPrimitiveStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryPrimitiveStruct")); } return false; } - OnDeleteAllVecU32.Broadcast(Context, Args.N); + OnDeleteAllVecEveryPrimitiveStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteAllVecU64(const TArray& N) +void URemoteReducers::DeleteAllVecEveryVecStruct(const TArray& S) { if (!Conn) { @@ -4540,32 +4608,814 @@ void URemoteReducers::DeleteAllVecU64(const TArray& N) return; } - FDeleteAllVecU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU64(ReducerArgs)); } + FDeleteAllVecEveryVecStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_every_vec_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEveryVecStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU64(const FReducerEventContext& Context, const UDeleteAllVecU64Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecEveryVecStruct(const FReducerEventContext& Context, const UDeleteAllVecEveryVecStructReducer* Args) { - if (!OnDeleteAllVecU64.IsBound()) + if (!OnDeleteAllVecEveryVecStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryVecStruct")); } return false; } - OnDeleteAllVecU64.Broadcast(Context, Args->N); + OnDeleteAllVecEveryVecStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteAllVecU64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU64Args& Args) +bool URemoteReducers::InvokeDeleteAllVecEveryVecStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEveryVecStructArgs& Args) { - if (!OnDeleteAllVecU64.IsBound()) + if (!OnDeleteAllVecEveryVecStruct.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryVecStruct")); + } + return false; + } + + OnDeleteAllVecEveryVecStruct.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteAllVecF32(const TArray& F) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecF32Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_f_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecF32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecF32(const FReducerEventContext& Context, const UDeleteAllVecF32Reducer* Args) +{ + if (!OnDeleteAllVecF32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF32")); + } + return false; + } + + OnDeleteAllVecF32.Broadcast(Context, Args->F); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecF32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecF32Args& Args) +{ + if (!OnDeleteAllVecF32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF32")); + } + return false; + } + + OnDeleteAllVecF32.Broadcast(Context, Args.F); + return true; +} + +void URemoteReducers::DeleteAllVecF64(const TArray& F) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecF64Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_f_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecF64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecF64(const FReducerEventContext& Context, const UDeleteAllVecF64Reducer* Args) +{ + if (!OnDeleteAllVecF64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF64")); + } + return false; + } + + OnDeleteAllVecF64.Broadcast(Context, Args->F); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecF64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecF64Args& Args) +{ + if (!OnDeleteAllVecF64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF64")); + } + return false; + } + + OnDeleteAllVecF64.Broadcast(Context, Args.F); + return true; +} + +void URemoteReducers::DeleteAllVecI128(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI128(const FReducerEventContext& Context, const UDeleteAllVecI128Reducer* Args) +{ + if (!OnDeleteAllVecI128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI128")); + } + return false; + } + + OnDeleteAllVecI128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI128WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI128Args& Args) +{ + if (!OnDeleteAllVecI128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI128")); + } + return false; + } + + OnDeleteAllVecI128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI16(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI16(const FReducerEventContext& Context, const UDeleteAllVecI16Reducer* Args) +{ + if (!OnDeleteAllVecI16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI16")); + } + return false; + } + + OnDeleteAllVecI16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI16WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI16Args& Args) +{ + if (!OnDeleteAllVecI16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI16")); + } + return false; + } + + OnDeleteAllVecI16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI256(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI256(const FReducerEventContext& Context, const UDeleteAllVecI256Reducer* Args) +{ + if (!OnDeleteAllVecI256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI256")); + } + return false; + } + + OnDeleteAllVecI256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI256WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI256Args& Args) +{ + if (!OnDeleteAllVecI256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI256")); + } + return false; + } + + OnDeleteAllVecI256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI32(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI32(const FReducerEventContext& Context, const UDeleteAllVecI32Reducer* Args) +{ + if (!OnDeleteAllVecI32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI32")); + } + return false; + } + + OnDeleteAllVecI32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI32Args& Args) +{ + if (!OnDeleteAllVecI32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI32")); + } + return false; + } + + OnDeleteAllVecI32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI64(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI64(const FReducerEventContext& Context, const UDeleteAllVecI64Reducer* Args) +{ + if (!OnDeleteAllVecI64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI64")); + } + return false; + } + + OnDeleteAllVecI64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI64Args& Args) +{ + if (!OnDeleteAllVecI64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI64")); + } + return false; + } + + OnDeleteAllVecI64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI8(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI8(const FReducerEventContext& Context, const UDeleteAllVecI8Reducer* Args) +{ + if (!OnDeleteAllVecI8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI8")); + } + return false; + } + + OnDeleteAllVecI8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI8WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI8Args& Args) +{ + if (!OnDeleteAllVecI8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI8")); + } + return false; + } + + OnDeleteAllVecI8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecIdentity(const TArray& I) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecIdentity(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecIdentity(const FReducerEventContext& Context, const UDeleteAllVecIdentityReducer* Args) +{ + if (!OnDeleteAllVecIdentity.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecIdentity")); + } + return false; + } + + OnDeleteAllVecIdentity.Broadcast(Context, Args->I); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllVecIdentityArgs& Args) +{ + if (!OnDeleteAllVecIdentity.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecIdentity")); + } + return false; + } + + OnDeleteAllVecIdentity.Broadcast(Context, Args.I); + return true; +} + +void URemoteReducers::DeleteAllVecSimpleEnum(const TArray& E) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecSimpleEnumArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecSimpleEnum(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecSimpleEnum(const FReducerEventContext& Context, const UDeleteAllVecSimpleEnumReducer* Args) +{ + if (!OnDeleteAllVecSimpleEnum.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecSimpleEnum")); + } + return false; + } + + OnDeleteAllVecSimpleEnum.Broadcast(Context, Args->E); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecSimpleEnumWithArgs(const FReducerEventContext& Context, const FDeleteAllVecSimpleEnumArgs& Args) +{ + if (!OnDeleteAllVecSimpleEnum.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecSimpleEnum")); + } + return false; + } + + OnDeleteAllVecSimpleEnum.Broadcast(Context, Args.E); + return true; +} + +void URemoteReducers::DeleteAllVecString(const TArray& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecString(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecString(const FReducerEventContext& Context, const UDeleteAllVecStringReducer* Args) +{ + if (!OnDeleteAllVecString.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecString")); + } + return false; + } + + OnDeleteAllVecString.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecStringWithArgs(const FReducerEventContext& Context, const FDeleteAllVecStringArgs& Args) +{ + if (!OnDeleteAllVecString.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecString")); + } + return false; + } + + OnDeleteAllVecString.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteAllVecTimestamp(const TArray& T) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecTimestampArgs ReducerArgs(T); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_timestamp"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecTimestamp(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecTimestamp(const FReducerEventContext& Context, const UDeleteAllVecTimestampReducer* Args) +{ + if (!OnDeleteAllVecTimestamp.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecTimestamp")); + } + return false; + } + + OnDeleteAllVecTimestamp.Broadcast(Context, Args->T); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecTimestampWithArgs(const FReducerEventContext& Context, const FDeleteAllVecTimestampArgs& Args) +{ + if (!OnDeleteAllVecTimestamp.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecTimestamp")); + } + return false; + } + + OnDeleteAllVecTimestamp.Broadcast(Context, Args.T); + return true; +} + +void URemoteReducers::DeleteAllVecU128(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU128(const FReducerEventContext& Context, const UDeleteAllVecU128Reducer* Args) +{ + if (!OnDeleteAllVecU128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU128")); + } + return false; + } + + OnDeleteAllVecU128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU128WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU128Args& Args) +{ + if (!OnDeleteAllVecU128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU128")); + } + return false; + } + + OnDeleteAllVecU128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU16(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU16(const FReducerEventContext& Context, const UDeleteAllVecU16Reducer* Args) +{ + if (!OnDeleteAllVecU16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU16")); + } + return false; + } + + OnDeleteAllVecU16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU16WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU16Args& Args) +{ + if (!OnDeleteAllVecU16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU16")); + } + return false; + } + + OnDeleteAllVecU16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU256(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU256(const FReducerEventContext& Context, const UDeleteAllVecU256Reducer* Args) +{ + if (!OnDeleteAllVecU256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU256")); + } + return false; + } + + OnDeleteAllVecU256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU256WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU256Args& Args) +{ + if (!OnDeleteAllVecU256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU256")); + } + return false; + } + + OnDeleteAllVecU256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU32(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU32(const FReducerEventContext& Context, const UDeleteAllVecU32Reducer* Args) +{ + if (!OnDeleteAllVecU32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU32")); + } + return false; + } + + OnDeleteAllVecU32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU32Args& Args) +{ + if (!OnDeleteAllVecU32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU32")); + } + return false; + } + + OnDeleteAllVecU32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU64(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU64(const FReducerEventContext& Context, const UDeleteAllVecU64Reducer* Args) +{ + if (!OnDeleteAllVecU64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU64")); + } + return false; + } + + OnDeleteAllVecU64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU64Args& Args) +{ + if (!OnDeleteAllVecU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { @@ -4574,11 +5424,2150 @@ bool URemoteReducers::InvokeDeleteAllVecU64WithArgs(const FReducerEventContext& return false; } - OnDeleteAllVecU64.Broadcast(Context, Args.N); + OnDeleteAllVecU64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU8(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU8(const FReducerEventContext& Context, const UDeleteAllVecU8Reducer* Args) +{ + if (!OnDeleteAllVecU8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU8")); + } + return false; + } + + OnDeleteAllVecU8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU8WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU8Args& Args) +{ + if (!OnDeleteAllVecU8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU8")); + } + return false; + } + + OnDeleteAllVecU8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecUnitStruct(const TArray& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecUnitStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_unit_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecUnitStruct(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecUnitStruct(const FReducerEventContext& Context, const UDeleteAllVecUnitStructReducer* Args) +{ + if (!OnDeleteAllVecUnitStruct.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUnitStruct")); + } + return false; + } + + OnDeleteAllVecUnitStruct.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecUnitStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecUnitStructArgs& Args) +{ + if (!OnDeleteAllVecUnitStruct.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUnitStruct")); + } + return false; + } + + OnDeleteAllVecUnitStruct.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteAllVecUuid(const TArray& U) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecUuid(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecUuid(const FReducerEventContext& Context, const UDeleteAllVecUuidReducer* Args) +{ + if (!OnDeleteAllVecUuid.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUuid")); + } + return false; + } + + OnDeleteAllVecUuid.Broadcast(Context, Args->U); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllVecUuidArgs& Args) +{ + if (!OnDeleteAllVecUuid.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUuid")); + } + return false; + } + + OnDeleteAllVecUuid.Broadcast(Context, Args.U); + return true; +} + +void URemoteReducers::DeleteFromBtreeU32(const TArray& Rows) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteFromBtreeU32Args ReducerArgs(Rows); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_from_btree_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteFromBtreeU32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteFromBtreeU32(const FReducerEventContext& Context, const UDeleteFromBtreeU32Reducer* Args) +{ + if (!OnDeleteFromBtreeU32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteFromBtreeU32")); + } + return false; + } + + OnDeleteFromBtreeU32.Broadcast(Context, Args->Rows); + return true; +} + +bool URemoteReducers::InvokeDeleteFromBtreeU32WithArgs(const FReducerEventContext& Context, const FDeleteFromBtreeU32Args& Args) +{ + if (!OnDeleteFromBtreeU32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteFromBtreeU32")); + } + return false; + } + + OnDeleteFromBtreeU32.Broadcast(Context, Args.Rows); + return true; +} + +void URemoteReducers::DeleteLargeTable(const uint8 A, const uint16 B, const uint32 C, const uint64 D, const FSpacetimeDBUInt128& E, const FSpacetimeDBUInt256& F, const int8 G, const int16 H, const int32 I, const int64 J, const FSpacetimeDBInt128& K, const FSpacetimeDBInt256& L, const bool M, const float N, const double O, const FString& P, const ESimpleEnumType& Q, const FEnumWithPayloadType& R, const FUnitStructType& S, const FByteStructType& T, const FEveryPrimitiveStructType& U, const FEveryVecStructType& V) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteLargeTableArgs ReducerArgs(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_large_table"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteLargeTable(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteLargeTable(const FReducerEventContext& Context, const UDeleteLargeTableReducer* Args) +{ + if (!OnDeleteLargeTable.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteLargeTable")); + } + return false; + } + + FDeleteLargeTableArgs ArgsStruct; + ArgsStruct.A = Args->A; + ArgsStruct.B = Args->B; + ArgsStruct.C = Args->C; + ArgsStruct.D = Args->D; + ArgsStruct.E = Args->E; + ArgsStruct.F = Args->F; + ArgsStruct.G = Args->G; + ArgsStruct.H = Args->H; + ArgsStruct.I = Args->I; + ArgsStruct.J = Args->J; + ArgsStruct.K = Args->K; + ArgsStruct.L = Args->L; + ArgsStruct.M = Args->M; + ArgsStruct.N = Args->N; + ArgsStruct.O = Args->O; + ArgsStruct.P = Args->P; + ArgsStruct.Q = Args->Q; + ArgsStruct.R = Args->R; + ArgsStruct.S = Args->S; + ArgsStruct.T = Args->T; + ArgsStruct.U = Args->U; + ArgsStruct.V = Args->V; + OnDeleteLargeTable.Broadcast(Context, ArgsStruct); + return true; +} + +bool URemoteReducers::InvokeDeleteLargeTableWithArgs(const FReducerEventContext& Context, const FDeleteLargeTableArgs& Args) +{ + if (!OnDeleteLargeTable.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteLargeTable")); + } + return false; + } + + OnDeleteLargeTable.Broadcast(Context, Args); + return true; +} + +void URemoteReducers::DeletePkBool(const bool B) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkBool(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkBool(const FReducerEventContext& Context, const UDeletePkBoolReducer* Args) +{ + if (!OnDeletePkBool.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkBool")); + } + return false; + } + + OnDeletePkBool.Broadcast(Context, Args->B); + return true; +} + +bool URemoteReducers::InvokeDeletePkBoolWithArgs(const FReducerEventContext& Context, const FDeletePkBoolArgs& Args) +{ + if (!OnDeletePkBool.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkBool")); + } + return false; + } + + OnDeletePkBool.Broadcast(Context, Args.B); + return true; +} + +void URemoteReducers::DeletePkConnectionId(const FSpacetimeDBConnectionId& A) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkConnectionId(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkConnectionId(const FReducerEventContext& Context, const UDeletePkConnectionIdReducer* Args) +{ + if (!OnDeletePkConnectionId.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkConnectionId")); + } + return false; + } + + OnDeletePkConnectionId.Broadcast(Context, Args->A); + return true; +} + +bool URemoteReducers::InvokeDeletePkConnectionIdWithArgs(const FReducerEventContext& Context, const FDeletePkConnectionIdArgs& Args) +{ + if (!OnDeletePkConnectionId.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkConnectionId")); + } + return false; + } + + OnDeletePkConnectionId.Broadcast(Context, Args.A); + return true; +} + +void URemoteReducers::DeletePkI128(const FSpacetimeDBInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI128(const FReducerEventContext& Context, const UDeletePkI128Reducer* Args) +{ + if (!OnDeletePkI128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI128")); + } + return false; + } + + OnDeletePkI128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI128WithArgs(const FReducerEventContext& Context, const FDeletePkI128Args& Args) +{ + if (!OnDeletePkI128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI128")); + } + return false; + } + + OnDeletePkI128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI16(const int16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI16(const FReducerEventContext& Context, const UDeletePkI16Reducer* Args) +{ + if (!OnDeletePkI16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI16")); + } + return false; + } + + OnDeletePkI16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI16WithArgs(const FReducerEventContext& Context, const FDeletePkI16Args& Args) +{ + if (!OnDeletePkI16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI16")); + } + return false; + } + + OnDeletePkI16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI256(const FSpacetimeDBInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI256(const FReducerEventContext& Context, const UDeletePkI256Reducer* Args) +{ + if (!OnDeletePkI256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI256")); + } + return false; + } + + OnDeletePkI256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI256WithArgs(const FReducerEventContext& Context, const FDeletePkI256Args& Args) +{ + if (!OnDeletePkI256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI256")); + } + return false; + } + + OnDeletePkI256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI32(const int32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI32(const FReducerEventContext& Context, const UDeletePkI32Reducer* Args) +{ + if (!OnDeletePkI32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI32")); + } + return false; + } + + OnDeletePkI32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI32WithArgs(const FReducerEventContext& Context, const FDeletePkI32Args& Args) +{ + if (!OnDeletePkI32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI32")); + } + return false; + } + + OnDeletePkI32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI64(const int64 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI64(const FReducerEventContext& Context, const UDeletePkI64Reducer* Args) +{ + if (!OnDeletePkI64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI64")); + } + return false; + } + + OnDeletePkI64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI64WithArgs(const FReducerEventContext& Context, const FDeletePkI64Args& Args) +{ + if (!OnDeletePkI64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI64")); + } + return false; + } + + OnDeletePkI64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI8(const int8 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI8(const FReducerEventContext& Context, const UDeletePkI8Reducer* Args) +{ + if (!OnDeletePkI8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI8")); + } + return false; + } + + OnDeletePkI8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI8WithArgs(const FReducerEventContext& Context, const FDeletePkI8Args& Args) +{ + if (!OnDeletePkI8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI8")); + } + return false; + } + + OnDeletePkI8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkIdentity(const FSpacetimeDBIdentity& I) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkIdentity(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkIdentity(const FReducerEventContext& Context, const UDeletePkIdentityReducer* Args) +{ + if (!OnDeletePkIdentity.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkIdentity")); + } + return false; + } + + OnDeletePkIdentity.Broadcast(Context, Args->I); + return true; +} + +bool URemoteReducers::InvokeDeletePkIdentityWithArgs(const FReducerEventContext& Context, const FDeletePkIdentityArgs& Args) +{ + if (!OnDeletePkIdentity.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkIdentity")); + } + return false; + } + + OnDeletePkIdentity.Broadcast(Context, Args.I); + return true; +} + +void URemoteReducers::DeletePkString(const FString& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkString(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkString(const FReducerEventContext& Context, const UDeletePkStringReducer* Args) +{ + if (!OnDeletePkString.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkString")); + } + return false; + } + + OnDeletePkString.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeletePkStringWithArgs(const FReducerEventContext& Context, const FDeletePkStringArgs& Args) +{ + if (!OnDeletePkString.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkString")); + } + return false; + } + + OnDeletePkString.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeletePkU128(const FSpacetimeDBUInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU128(const FReducerEventContext& Context, const UDeletePkU128Reducer* Args) +{ + if (!OnDeletePkU128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU128")); + } + return false; + } + + OnDeletePkU128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU128WithArgs(const FReducerEventContext& Context, const FDeletePkU128Args& Args) +{ + if (!OnDeletePkU128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU128")); + } + return false; + } + + OnDeletePkU128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU16(const uint16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU16(const FReducerEventContext& Context, const UDeletePkU16Reducer* Args) +{ + if (!OnDeletePkU16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU16")); + } + return false; + } + + OnDeletePkU16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU16WithArgs(const FReducerEventContext& Context, const FDeletePkU16Args& Args) +{ + if (!OnDeletePkU16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU16")); + } + return false; + } + + OnDeletePkU16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU256(const FSpacetimeDBUInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU256(const FReducerEventContext& Context, const UDeletePkU256Reducer* Args) +{ + if (!OnDeletePkU256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU256")); + } + return false; + } + + OnDeletePkU256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU256WithArgs(const FReducerEventContext& Context, const FDeletePkU256Args& Args) +{ + if (!OnDeletePkU256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU256")); + } + return false; + } + + OnDeletePkU256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU32(const uint32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU32(const FReducerEventContext& Context, const UDeletePkU32Reducer* Args) +{ + if (!OnDeletePkU32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32")); + } + return false; + } + + OnDeletePkU32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU32WithArgs(const FReducerEventContext& Context, const FDeletePkU32Args& Args) +{ + if (!OnDeletePkU32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32")); + } + return false; + } + + OnDeletePkU32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU32InsertPkU32Two(const uint32 N, const int32 Data) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU32InsertPkU32TwoArgs ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32_insert_pk_u_32_two"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32InsertPkU32Two(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU32InsertPkU32Two(const FReducerEventContext& Context, const UDeletePkU32InsertPkU32TwoReducer* Args) +{ + if (!OnDeletePkU32InsertPkU32Two.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32InsertPkU32Two")); + } + return false; + } + + OnDeletePkU32InsertPkU32Two.Broadcast(Context, Args->N, Args->Data); + return true; +} + +bool URemoteReducers::InvokeDeletePkU32InsertPkU32TwoWithArgs(const FReducerEventContext& Context, const FDeletePkU32InsertPkU32TwoArgs& Args) +{ + if (!OnDeletePkU32InsertPkU32Two.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32InsertPkU32Two")); + } + return false; + } + + OnDeletePkU32InsertPkU32Two.Broadcast(Context, Args.N, Args.Data); + return true; +} + +void URemoteReducers::DeletePkU32Two(const uint32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU32TwoArgs ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32_two"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32Two(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU32Two(const FReducerEventContext& Context, const UDeletePkU32TwoReducer* Args) +{ + if (!OnDeletePkU32Two.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32Two")); + } + return false; + } + + OnDeletePkU32Two.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU32TwoWithArgs(const FReducerEventContext& Context, const FDeletePkU32TwoArgs& Args) +{ + if (!OnDeletePkU32Two.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32Two")); + } + return false; + } + + OnDeletePkU32Two.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU64(const uint64 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU64(const FReducerEventContext& Context, const UDeletePkU64Reducer* Args) +{ + if (!OnDeletePkU64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU64")); + } + return false; + } + + OnDeletePkU64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU64WithArgs(const FReducerEventContext& Context, const FDeletePkU64Args& Args) +{ + if (!OnDeletePkU64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU64")); + } + return false; + } + + OnDeletePkU64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU8(const uint8 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU8(const FReducerEventContext& Context, const UDeletePkU8Reducer* Args) +{ + if (!OnDeletePkU8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU8")); + } + return false; + } + + OnDeletePkU8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU8WithArgs(const FReducerEventContext& Context, const FDeletePkU8Args& Args) +{ + if (!OnDeletePkU8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU8")); + } + return false; + } + + OnDeletePkU8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkUuid(const FSpacetimeDBUuid& U) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkUuid(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkUuid(const FReducerEventContext& Context, const UDeletePkUuidReducer* Args) +{ + if (!OnDeletePkUuid.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkUuid")); + } + return false; + } + + OnDeletePkUuid.Broadcast(Context, Args->U); + return true; +} + +bool URemoteReducers::InvokeDeletePkUuidWithArgs(const FReducerEventContext& Context, const FDeletePkUuidArgs& Args) +{ + if (!OnDeletePkUuid.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkUuid")); + } + return false; + } + + OnDeletePkUuid.Broadcast(Context, Args.U); + return true; +} + +void URemoteReducers::DeleteUniqueBool(const bool B) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueBool(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueBool(const FReducerEventContext& Context, const UDeleteUniqueBoolReducer* Args) +{ + if (!OnDeleteUniqueBool.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueBool")); + } + return false; + } + + OnDeleteUniqueBool.Broadcast(Context, Args->B); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueBoolWithArgs(const FReducerEventContext& Context, const FDeleteUniqueBoolArgs& Args) +{ + if (!OnDeleteUniqueBool.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueBool")); + } + return false; + } + + OnDeleteUniqueBool.Broadcast(Context, Args.B); + return true; +} + +void URemoteReducers::DeleteUniqueConnectionId(const FSpacetimeDBConnectionId& A) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueConnectionId(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueConnectionId(const FReducerEventContext& Context, const UDeleteUniqueConnectionIdReducer* Args) +{ + if (!OnDeleteUniqueConnectionId.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueConnectionId")); + } + return false; + } + + OnDeleteUniqueConnectionId.Broadcast(Context, Args->A); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteUniqueConnectionIdArgs& Args) +{ + if (!OnDeleteUniqueConnectionId.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueConnectionId")); + } + return false; + } + + OnDeleteUniqueConnectionId.Broadcast(Context, Args.A); + return true; +} + +void URemoteReducers::DeleteUniqueI128(const FSpacetimeDBInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI128(const FReducerEventContext& Context, const UDeleteUniqueI128Reducer* Args) +{ + if (!OnDeleteUniqueI128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI128")); + } + return false; + } + + OnDeleteUniqueI128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI128Args& Args) +{ + if (!OnDeleteUniqueI128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI128")); + } + return false; + } + + OnDeleteUniqueI128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI16(const int16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI16(const FReducerEventContext& Context, const UDeleteUniqueI16Reducer* Args) +{ + if (!OnDeleteUniqueI16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI16")); + } + return false; + } + + OnDeleteUniqueI16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI16Args& Args) +{ + if (!OnDeleteUniqueI16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI16")); + } + return false; + } + + OnDeleteUniqueI16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI256(const FSpacetimeDBInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI256(const FReducerEventContext& Context, const UDeleteUniqueI256Reducer* Args) +{ + if (!OnDeleteUniqueI256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI256")); + } + return false; + } + + OnDeleteUniqueI256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI256Args& Args) +{ + if (!OnDeleteUniqueI256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI256")); + } + return false; + } + + OnDeleteUniqueI256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI32(const int32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI32(const FReducerEventContext& Context, const UDeleteUniqueI32Reducer* Args) +{ + if (!OnDeleteUniqueI32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI32")); + } + return false; + } + + OnDeleteUniqueI32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI32Args& Args) +{ + if (!OnDeleteUniqueI32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI32")); + } + return false; + } + + OnDeleteUniqueI32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI64(const int64 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI64(const FReducerEventContext& Context, const UDeleteUniqueI64Reducer* Args) +{ + if (!OnDeleteUniqueI64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI64")); + } + return false; + } + + OnDeleteUniqueI64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI64Args& Args) +{ + if (!OnDeleteUniqueI64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI64")); + } + return false; + } + + OnDeleteUniqueI64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI8(const int8 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI8(const FReducerEventContext& Context, const UDeleteUniqueI8Reducer* Args) +{ + if (!OnDeleteUniqueI8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI8")); + } + return false; + } + + OnDeleteUniqueI8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI8Args& Args) +{ + if (!OnDeleteUniqueI8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI8")); + } + return false; + } + + OnDeleteUniqueI8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueIdentity(const FSpacetimeDBIdentity& I) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueIdentity(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueIdentity(const FReducerEventContext& Context, const UDeleteUniqueIdentityReducer* Args) +{ + if (!OnDeleteUniqueIdentity.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueIdentity")); + } + return false; + } + + OnDeleteUniqueIdentity.Broadcast(Context, Args->I); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueIdentityArgs& Args) +{ + if (!OnDeleteUniqueIdentity.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueIdentity")); + } + return false; + } + + OnDeleteUniqueIdentity.Broadcast(Context, Args.I); + return true; +} + +void URemoteReducers::DeleteUniqueOptionBool(const FTestClientOptionalBool B) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionBool(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionBool(const FReducerEventContext& Context, const UDeleteUniqueOptionBoolReducer* Args) +{ + if (!OnDeleteUniqueOptionBool.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionBool")); + } + return false; + } + + OnDeleteUniqueOptionBool.Broadcast(Context, Args->B); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionBoolArgs& Args) +{ + if (!OnDeleteUniqueOptionBool.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionBool")); + } + return false; + } + + OnDeleteUniqueOptionBool.Broadcast(Context, Args.B); + return true; +} + +void URemoteReducers::DeleteUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionConnectionId(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionConnectionId(const FReducerEventContext& Context, const UDeleteUniqueOptionConnectionIdReducer* Args) +{ + if (!OnDeleteUniqueOptionConnectionId.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionConnectionId")); + } + return false; + } + + OnDeleteUniqueOptionConnectionId.Broadcast(Context, Args->A); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionConnectionIdArgs& Args) +{ + if (!OnDeleteUniqueOptionConnectionId.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionConnectionId")); + } + return false; + } + + OnDeleteUniqueOptionConnectionId.Broadcast(Context, Args.A); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI128(const FTestClientOptionalInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI128(const FReducerEventContext& Context, const UDeleteUniqueOptionI128Reducer* Args) +{ + if (!OnDeleteUniqueOptionI128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI128")); + } + return false; + } + + OnDeleteUniqueOptionI128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI128Args& Args) +{ + if (!OnDeleteUniqueOptionI128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI128")); + } + return false; + } + + OnDeleteUniqueOptionI128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI16(const FTestClientOptionalInt16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI16(const FReducerEventContext& Context, const UDeleteUniqueOptionI16Reducer* Args) +{ + if (!OnDeleteUniqueOptionI16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI16")); + } + return false; + } + + OnDeleteUniqueOptionI16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI16Args& Args) +{ + if (!OnDeleteUniqueOptionI16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI16")); + } + return false; + } + + OnDeleteUniqueOptionI16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI256(const FTestClientOptionalInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI256(const FReducerEventContext& Context, const UDeleteUniqueOptionI256Reducer* Args) +{ + if (!OnDeleteUniqueOptionI256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI256")); + } + return false; + } + + OnDeleteUniqueOptionI256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI256Args& Args) +{ + if (!OnDeleteUniqueOptionI256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI256")); + } + return false; + } + + OnDeleteUniqueOptionI256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI32(const FTestClientOptionalInt32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI32(const FReducerEventContext& Context, const UDeleteUniqueOptionI32Reducer* Args) +{ + if (!OnDeleteUniqueOptionI32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI32")); + } + return false; + } + + OnDeleteUniqueOptionI32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI32Args& Args) +{ + if (!OnDeleteUniqueOptionI32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI32")); + } + return false; + } + + OnDeleteUniqueOptionI32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI64(const FTestClientOptionalInt64 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI64(const FReducerEventContext& Context, const UDeleteUniqueOptionI64Reducer* Args) +{ + if (!OnDeleteUniqueOptionI64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI64")); + } + return false; + } + + OnDeleteUniqueOptionI64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI64Args& Args) +{ + if (!OnDeleteUniqueOptionI64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI64")); + } + return false; + } + + OnDeleteUniqueOptionI64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI8(const FTestClientOptionalInt8 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI8(const FReducerEventContext& Context, const UDeleteUniqueOptionI8Reducer* Args) +{ + if (!OnDeleteUniqueOptionI8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI8")); + } + return false; + } + + OnDeleteUniqueOptionI8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI8Args& Args) +{ + if (!OnDeleteUniqueOptionI8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI8")); + } + return false; + } + + OnDeleteUniqueOptionI8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionIdentity(const FTestClientOptionalIdentity& I) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionIdentity(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionIdentity(const FReducerEventContext& Context, const UDeleteUniqueOptionIdentityReducer* Args) +{ + if (!OnDeleteUniqueOptionIdentity.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionIdentity")); + } + return false; + } + + OnDeleteUniqueOptionIdentity.Broadcast(Context, Args->I); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionIdentityArgs& Args) +{ + if (!OnDeleteUniqueOptionIdentity.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionIdentity")); + } + return false; + } + + OnDeleteUniqueOptionIdentity.Broadcast(Context, Args.I); + return true; +} + +void URemoteReducers::DeleteUniqueOptionString(const FTestClientOptionalString& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionString(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionString(const FReducerEventContext& Context, const UDeleteUniqueOptionStringReducer* Args) +{ + if (!OnDeleteUniqueOptionString.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionString")); + } + return false; + } + + OnDeleteUniqueOptionString.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionStringArgs& Args) +{ + if (!OnDeleteUniqueOptionString.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionString")); + } + return false; + } + + OnDeleteUniqueOptionString.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteUniqueOptionU128(const FTestClientOptionalUInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU128(const FReducerEventContext& Context, const UDeleteUniqueOptionU128Reducer* Args) +{ + if (!OnDeleteUniqueOptionU128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU128")); + } + return false; + } + + OnDeleteUniqueOptionU128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU128Args& Args) +{ + if (!OnDeleteUniqueOptionU128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU128")); + } + return false; + } + + OnDeleteUniqueOptionU128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionU16(const FTestClientOptionalUInt16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU16(const FReducerEventContext& Context, const UDeleteUniqueOptionU16Reducer* Args) +{ + if (!OnDeleteUniqueOptionU16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU16")); + } + return false; + } + + OnDeleteUniqueOptionU16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU16Args& Args) +{ + if (!OnDeleteUniqueOptionU16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU16")); + } + return false; + } + + OnDeleteUniqueOptionU16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionU256(const FTestClientOptionalUInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU256(const FReducerEventContext& Context, const UDeleteUniqueOptionU256Reducer* Args) +{ + if (!OnDeleteUniqueOptionU256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU256")); + } + return false; + } + + OnDeleteUniqueOptionU256.Broadcast(Context, Args->N); return true; } -void URemoteReducers::DeleteAllVecU8(const TArray& N) +bool URemoteReducers::InvokeDeleteUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU256Args& Args) +{ + if (!OnDeleteUniqueOptionU256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU256")); + } + return false; + } + + OnDeleteUniqueOptionU256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionU32(const FTestClientOptionalUInt32 N) { if (!Conn) { @@ -4586,45 +7575,45 @@ void URemoteReducers::DeleteAllVecU8(const TArray& N) return; } - FDeleteAllVecU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU8(ReducerArgs)); } + FDeleteUniqueOptionU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU8(const FReducerEventContext& Context, const UDeleteAllVecU8Reducer* Args) +bool URemoteReducers::InvokeDeleteUniqueOptionU32(const FReducerEventContext& Context, const UDeleteUniqueOptionU32Reducer* Args) { - if (!OnDeleteAllVecU8.IsBound()) + if (!OnDeleteUniqueOptionU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU32")); } return false; } - OnDeleteAllVecU8.Broadcast(Context, Args->N); + OnDeleteUniqueOptionU32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteAllVecU8WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU8Args& Args) +bool URemoteReducers::InvokeDeleteUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU32Args& Args) { - if (!OnDeleteAllVecU8.IsBound()) + if (!OnDeleteUniqueOptionU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU32")); } return false; } - OnDeleteAllVecU8.Broadcast(Context, Args.N); + OnDeleteUniqueOptionU32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteAllVecUnitStruct(const TArray& S) +void URemoteReducers::DeleteUniqueOptionU64(const FTestClientOptionalUInt64 N) { if (!Conn) { @@ -4632,45 +7621,45 @@ void URemoteReducers::DeleteAllVecUnitStruct(const TArray& S) return; } - FDeleteAllVecUnitStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_unit_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecUnitStruct(ReducerArgs)); } + FDeleteUniqueOptionU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecUnitStruct(const FReducerEventContext& Context, const UDeleteAllVecUnitStructReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueOptionU64(const FReducerEventContext& Context, const UDeleteUniqueOptionU64Reducer* Args) { - if (!OnDeleteAllVecUnitStruct.IsBound()) + if (!OnDeleteUniqueOptionU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU64")); } return false; } - OnDeleteAllVecUnitStruct.Broadcast(Context, Args->S); + OnDeleteUniqueOptionU64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteAllVecUnitStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecUnitStructArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU64Args& Args) { - if (!OnDeleteAllVecUnitStruct.IsBound()) + if (!OnDeleteUniqueOptionU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU64")); } return false; } - OnDeleteAllVecUnitStruct.Broadcast(Context, Args.S); + OnDeleteUniqueOptionU64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteAllVecUuid(const TArray& U) +void URemoteReducers::DeleteUniqueOptionU8(const FTestClientOptionalUInt8 N) { if (!Conn) { @@ -4678,45 +7667,275 @@ void URemoteReducers::DeleteAllVecUuid(const TArray& U) return; } - FDeleteAllVecUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecUuid(ReducerArgs)); } + FDeleteUniqueOptionU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU8(const FReducerEventContext& Context, const UDeleteUniqueOptionU8Reducer* Args) +{ + if (!OnDeleteUniqueOptionU8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU8")); + } + return false; + } + + OnDeleteUniqueOptionU8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU8Args& Args) +{ + if (!OnDeleteUniqueOptionU8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU8")); + } + return false; + } + + OnDeleteUniqueOptionU8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionUuid(const FTestClientOptionalUuid& U) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionUuid(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionUuid(const FReducerEventContext& Context, const UDeleteUniqueOptionUuidReducer* Args) +{ + if (!OnDeleteUniqueOptionUuid.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionUuid")); + } + return false; + } + + OnDeleteUniqueOptionUuid.Broadcast(Context, Args->U); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionUuidArgs& Args) +{ + if (!OnDeleteUniqueOptionUuid.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionUuid")); + } + return false; + } + + OnDeleteUniqueOptionUuid.Broadcast(Context, Args.U); + return true; +} + +void URemoteReducers::DeleteUniqueString(const FString& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueString(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueString(const FReducerEventContext& Context, const UDeleteUniqueStringReducer* Args) +{ + if (!OnDeleteUniqueString.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueString")); + } + return false; + } + + OnDeleteUniqueString.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueStringArgs& Args) +{ + if (!OnDeleteUniqueString.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueString")); + } + return false; + } + + OnDeleteUniqueString.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteUniqueU128(const FSpacetimeDBUInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueU128(const FReducerEventContext& Context, const UDeleteUniqueU128Reducer* Args) +{ + if (!OnDeleteUniqueU128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU128")); + } + return false; + } + + OnDeleteUniqueU128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU128Args& Args) +{ + if (!OnDeleteUniqueU128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU128")); + } + return false; + } + + OnDeleteUniqueU128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueU16(const uint16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueU16(const FReducerEventContext& Context, const UDeleteUniqueU16Reducer* Args) +{ + if (!OnDeleteUniqueU16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU16")); + } + return false; + } + + OnDeleteUniqueU16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU16Args& Args) +{ + if (!OnDeleteUniqueU16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU16")); + } + return false; + } + + OnDeleteUniqueU16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueU256(const FSpacetimeDBUInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecUuid(const FReducerEventContext& Context, const UDeleteAllVecUuidReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueU256(const FReducerEventContext& Context, const UDeleteUniqueU256Reducer* Args) { - if (!OnDeleteAllVecUuid.IsBound()) + if (!OnDeleteUniqueU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU256")); } return false; } - OnDeleteAllVecUuid.Broadcast(Context, Args->U); + OnDeleteUniqueU256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteAllVecUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllVecUuidArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU256Args& Args) { - if (!OnDeleteAllVecUuid.IsBound()) + if (!OnDeleteUniqueU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU256")); } return false; } - OnDeleteAllVecUuid.Broadcast(Context, Args.U); + OnDeleteUniqueU256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteFromBtreeU32(const TArray& Rows) +void URemoteReducers::DeleteUniqueU32(const uint32 N) { if (!Conn) { @@ -4724,45 +7943,45 @@ void URemoteReducers::DeleteFromBtreeU32(const TArray& Rows) return; } - FDeleteFromBtreeU32Args ReducerArgs(Rows); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_from_btree_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteFromBtreeU32(ReducerArgs)); } + FDeleteUniqueU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteFromBtreeU32(const FReducerEventContext& Context, const UDeleteFromBtreeU32Reducer* Args) +bool URemoteReducers::InvokeDeleteUniqueU32(const FReducerEventContext& Context, const UDeleteUniqueU32Reducer* Args) { - if (!OnDeleteFromBtreeU32.IsBound()) + if (!OnDeleteUniqueU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteFromBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU32")); } return false; } - OnDeleteFromBtreeU32.Broadcast(Context, Args->Rows); + OnDeleteUniqueU32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteFromBtreeU32WithArgs(const FReducerEventContext& Context, const FDeleteFromBtreeU32Args& Args) +bool URemoteReducers::InvokeDeleteUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU32Args& Args) { - if (!OnDeleteFromBtreeU32.IsBound()) + if (!OnDeleteUniqueU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteFromBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU32")); } return false; } - OnDeleteFromBtreeU32.Broadcast(Context, Args.Rows); + OnDeleteUniqueU32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteLargeTable(const uint8 A, const uint16 B, const uint32 C, const uint64 D, const FSpacetimeDBUInt128& E, const FSpacetimeDBUInt256& F, const int8 G, const int16 H, const int32 I, const int64 J, const FSpacetimeDBInt128& K, const FSpacetimeDBInt256& L, const bool M, const float N, const double O, const FString& P, const ESimpleEnumType& Q, const FEnumWithPayloadType& R, const FUnitStructType& S, const FByteStructType& T, const FEveryPrimitiveStructType& U, const FEveryVecStructType& V) +void URemoteReducers::DeleteUniqueU64(const uint64 N) { if (!Conn) { @@ -4770,68 +7989,45 @@ void URemoteReducers::DeleteLargeTable(const uint8 A, const uint16 B, const uint return; } - FDeleteLargeTableArgs ReducerArgs(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_large_table"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteLargeTable(ReducerArgs)); } + FDeleteUniqueU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteLargeTable(const FReducerEventContext& Context, const UDeleteLargeTableReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueU64(const FReducerEventContext& Context, const UDeleteUniqueU64Reducer* Args) { - if (!OnDeleteLargeTable.IsBound()) + if (!OnDeleteUniqueU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteLargeTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU64")); } return false; } - FDeleteLargeTableArgs ArgsStruct; - ArgsStruct.A = Args->A; - ArgsStruct.B = Args->B; - ArgsStruct.C = Args->C; - ArgsStruct.D = Args->D; - ArgsStruct.E = Args->E; - ArgsStruct.F = Args->F; - ArgsStruct.G = Args->G; - ArgsStruct.H = Args->H; - ArgsStruct.I = Args->I; - ArgsStruct.J = Args->J; - ArgsStruct.K = Args->K; - ArgsStruct.L = Args->L; - ArgsStruct.M = Args->M; - ArgsStruct.N = Args->N; - ArgsStruct.O = Args->O; - ArgsStruct.P = Args->P; - ArgsStruct.Q = Args->Q; - ArgsStruct.R = Args->R; - ArgsStruct.S = Args->S; - ArgsStruct.T = Args->T; - ArgsStruct.U = Args->U; - ArgsStruct.V = Args->V; - OnDeleteLargeTable.Broadcast(Context, ArgsStruct); + OnDeleteUniqueU64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteLargeTableWithArgs(const FReducerEventContext& Context, const FDeleteLargeTableArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU64Args& Args) { - if (!OnDeleteLargeTable.IsBound()) + if (!OnDeleteUniqueU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteLargeTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU64")); } return false; } - OnDeleteLargeTable.Broadcast(Context, Args); + OnDeleteUniqueU64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeletePkBool(const bool B) +void URemoteReducers::DeleteUniqueU8(const uint8 N) { if (!Conn) { @@ -4839,45 +8035,45 @@ void URemoteReducers::DeletePkBool(const bool B) return; } - FDeletePkBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkBool(ReducerArgs)); } + FDeleteUniqueU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkBool(const FReducerEventContext& Context, const UDeletePkBoolReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueU8(const FReducerEventContext& Context, const UDeleteUniqueU8Reducer* Args) { - if (!OnDeletePkBool.IsBound()) + if (!OnDeleteUniqueU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU8")); } return false; } - OnDeletePkBool.Broadcast(Context, Args->B); + OnDeleteUniqueU8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeletePkBoolWithArgs(const FReducerEventContext& Context, const FDeletePkBoolArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU8Args& Args) { - if (!OnDeletePkBool.IsBound()) + if (!OnDeleteUniqueU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU8")); } return false; } - OnDeletePkBool.Broadcast(Context, Args.B); + OnDeleteUniqueU8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeletePkConnectionId(const FSpacetimeDBConnectionId& A) +void URemoteReducers::DeleteUniqueUuid(const FSpacetimeDBUuid& U) { if (!Conn) { @@ -4885,45 +8081,45 @@ void URemoteReducers::DeletePkConnectionId(const FSpacetimeDBConnectionId& A) return; } - FDeletePkConnectionIdArgs ReducerArgs(A); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkConnectionId(ReducerArgs)); } + FDeleteUniqueUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkConnectionId(const FReducerEventContext& Context, const UDeletePkConnectionIdReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueUuid(const FReducerEventContext& Context, const UDeleteUniqueUuidReducer* Args) { - if (!OnDeletePkConnectionId.IsBound()) + if (!OnDeleteUniqueUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueUuid")); } return false; } - OnDeletePkConnectionId.Broadcast(Context, Args->A); + OnDeleteUniqueUuid.Broadcast(Context, Args->U); return true; } -bool URemoteReducers::InvokeDeletePkConnectionIdWithArgs(const FReducerEventContext& Context, const FDeletePkConnectionIdArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueUuidArgs& Args) { - if (!OnDeletePkConnectionId.IsBound()) + if (!OnDeleteUniqueUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueUuid")); } return false; } - OnDeletePkConnectionId.Broadcast(Context, Args.A); + OnDeleteUniqueUuid.Broadcast(Context, Args.U); return true; } -void URemoteReducers::DeletePkI128(const FSpacetimeDBInt128& N) +void URemoteReducers::InsertCallTimestamp() { if (!Conn) { @@ -4931,45 +8127,45 @@ void URemoteReducers::DeletePkI128(const FSpacetimeDBInt128& N) return; } - FDeletePkI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI128(ReducerArgs)); } + FInsertCallTimestampArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_timestamp"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallTimestamp(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI128(const FReducerEventContext& Context, const UDeletePkI128Reducer* Args) +bool URemoteReducers::InvokeInsertCallTimestamp(const FReducerEventContext& Context, const UInsertCallTimestampReducer* Args) { - if (!OnDeletePkI128.IsBound()) + if (!OnInsertCallTimestamp.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallTimestamp")); } return false; } - OnDeletePkI128.Broadcast(Context, Args->N); + OnInsertCallTimestamp.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI128WithArgs(const FReducerEventContext& Context, const FDeletePkI128Args& Args) +bool URemoteReducers::InvokeInsertCallTimestampWithArgs(const FReducerEventContext& Context, const FInsertCallTimestampArgs& Args) { - if (!OnDeletePkI128.IsBound()) + if (!OnInsertCallTimestamp.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallTimestamp")); } return false; } - OnDeletePkI128.Broadcast(Context, Args.N); + OnInsertCallTimestamp.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI16(const int16 N) +void URemoteReducers::InsertCallUuidV4() { if (!Conn) { @@ -4977,45 +8173,45 @@ void URemoteReducers::DeletePkI16(const int16 N) return; } - FDeletePkI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI16(ReducerArgs)); } + FInsertCallUuidV4Args ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_uuid_v_4"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallUuidV4(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI16(const FReducerEventContext& Context, const UDeletePkI16Reducer* Args) +bool URemoteReducers::InvokeInsertCallUuidV4(const FReducerEventContext& Context, const UInsertCallUuidV4Reducer* Args) { - if (!OnDeletePkI16.IsBound()) + if (!OnInsertCallUuidV4.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV4")); } return false; } - OnDeletePkI16.Broadcast(Context, Args->N); + OnInsertCallUuidV4.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI16WithArgs(const FReducerEventContext& Context, const FDeletePkI16Args& Args) +bool URemoteReducers::InvokeInsertCallUuidV4WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV4Args& Args) { - if (!OnDeletePkI16.IsBound()) + if (!OnInsertCallUuidV4.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV4")); } return false; } - OnDeletePkI16.Broadcast(Context, Args.N); + OnInsertCallUuidV4.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI256(const FSpacetimeDBInt256& N) +void URemoteReducers::InsertCallUuidV7() { if (!Conn) { @@ -5023,45 +8219,45 @@ void URemoteReducers::DeletePkI256(const FSpacetimeDBInt256& N) return; } - FDeletePkI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI256(ReducerArgs)); } + FInsertCallUuidV7Args ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_uuid_v_7"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallUuidV7(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI256(const FReducerEventContext& Context, const UDeletePkI256Reducer* Args) +bool URemoteReducers::InvokeInsertCallUuidV7(const FReducerEventContext& Context, const UInsertCallUuidV7Reducer* Args) { - if (!OnDeletePkI256.IsBound()) + if (!OnInsertCallUuidV7.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV7")); } return false; } - OnDeletePkI256.Broadcast(Context, Args->N); + OnInsertCallUuidV7.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI256WithArgs(const FReducerEventContext& Context, const FDeletePkI256Args& Args) +bool URemoteReducers::InvokeInsertCallUuidV7WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV7Args& Args) { - if (!OnDeletePkI256.IsBound()) + if (!OnInsertCallUuidV7.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV7")); } return false; } - OnDeletePkI256.Broadcast(Context, Args.N); + OnInsertCallUuidV7.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI32(const int32 N) +void URemoteReducers::InsertCallerOneConnectionId() { if (!Conn) { @@ -5069,45 +8265,45 @@ void URemoteReducers::DeletePkI32(const int32 N) return; } - FDeletePkI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI32(ReducerArgs)); } + FInsertCallerOneConnectionIdArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_one_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerOneConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI32(const FReducerEventContext& Context, const UDeletePkI32Reducer* Args) +bool URemoteReducers::InvokeInsertCallerOneConnectionId(const FReducerEventContext& Context, const UInsertCallerOneConnectionIdReducer* Args) { - if (!OnDeletePkI32.IsBound()) + if (!OnInsertCallerOneConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneConnectionId")); } return false; } - OnDeletePkI32.Broadcast(Context, Args->N); + OnInsertCallerOneConnectionId.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI32WithArgs(const FReducerEventContext& Context, const FDeletePkI32Args& Args) +bool URemoteReducers::InvokeInsertCallerOneConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerOneConnectionIdArgs& Args) { - if (!OnDeletePkI32.IsBound()) + if (!OnInsertCallerOneConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneConnectionId")); } return false; } - OnDeletePkI32.Broadcast(Context, Args.N); + OnInsertCallerOneConnectionId.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI64(const int64 N) +void URemoteReducers::InsertCallerOneIdentity() { if (!Conn) { @@ -5115,45 +8311,45 @@ void URemoteReducers::DeletePkI64(const int64 N) return; } - FDeletePkI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI64(ReducerArgs)); } + FInsertCallerOneIdentityArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_one_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerOneIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI64(const FReducerEventContext& Context, const UDeletePkI64Reducer* Args) +bool URemoteReducers::InvokeInsertCallerOneIdentity(const FReducerEventContext& Context, const UInsertCallerOneIdentityReducer* Args) { - if (!OnDeletePkI64.IsBound()) + if (!OnInsertCallerOneIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneIdentity")); } return false; } - OnDeletePkI64.Broadcast(Context, Args->N); + OnInsertCallerOneIdentity.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI64WithArgs(const FReducerEventContext& Context, const FDeletePkI64Args& Args) +bool URemoteReducers::InvokeInsertCallerOneIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerOneIdentityArgs& Args) { - if (!OnDeletePkI64.IsBound()) + if (!OnInsertCallerOneIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneIdentity")); } return false; } - OnDeletePkI64.Broadcast(Context, Args.N); + OnInsertCallerOneIdentity.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI8(const int8 N) +void URemoteReducers::InsertCallerPkConnectionId(const int32 Data) { if (!Conn) { @@ -5161,45 +8357,45 @@ void URemoteReducers::DeletePkI8(const int8 N) return; } - FDeletePkI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI8(ReducerArgs)); } + FInsertCallerPkConnectionIdArgs ReducerArgs(Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_pk_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerPkConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI8(const FReducerEventContext& Context, const UDeletePkI8Reducer* Args) +bool URemoteReducers::InvokeInsertCallerPkConnectionId(const FReducerEventContext& Context, const UInsertCallerPkConnectionIdReducer* Args) { - if (!OnDeletePkI8.IsBound()) + if (!OnInsertCallerPkConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkConnectionId")); } return false; } - OnDeletePkI8.Broadcast(Context, Args->N); + OnInsertCallerPkConnectionId.Broadcast(Context, Args->Data); return true; } -bool URemoteReducers::InvokeDeletePkI8WithArgs(const FReducerEventContext& Context, const FDeletePkI8Args& Args) +bool URemoteReducers::InvokeInsertCallerPkConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerPkConnectionIdArgs& Args) { - if (!OnDeletePkI8.IsBound()) + if (!OnInsertCallerPkConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkConnectionId")); } return false; } - OnDeletePkI8.Broadcast(Context, Args.N); + OnInsertCallerPkConnectionId.Broadcast(Context, Args.Data); return true; } -void URemoteReducers::DeletePkIdentity(const FSpacetimeDBIdentity& I) +void URemoteReducers::InsertCallerPkIdentity(const int32 Data) { if (!Conn) { @@ -5207,45 +8403,45 @@ void URemoteReducers::DeletePkIdentity(const FSpacetimeDBIdentity& I) return; } - FDeletePkIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkIdentity(ReducerArgs)); } + FInsertCallerPkIdentityArgs ReducerArgs(Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_pk_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerPkIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkIdentity(const FReducerEventContext& Context, const UDeletePkIdentityReducer* Args) +bool URemoteReducers::InvokeInsertCallerPkIdentity(const FReducerEventContext& Context, const UInsertCallerPkIdentityReducer* Args) { - if (!OnDeletePkIdentity.IsBound()) + if (!OnInsertCallerPkIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkIdentity")); } return false; } - OnDeletePkIdentity.Broadcast(Context, Args->I); + OnInsertCallerPkIdentity.Broadcast(Context, Args->Data); return true; } -bool URemoteReducers::InvokeDeletePkIdentityWithArgs(const FReducerEventContext& Context, const FDeletePkIdentityArgs& Args) +bool URemoteReducers::InvokeInsertCallerPkIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerPkIdentityArgs& Args) { - if (!OnDeletePkIdentity.IsBound()) + if (!OnInsertCallerPkIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkIdentity")); } return false; } - OnDeletePkIdentity.Broadcast(Context, Args.I); + OnInsertCallerPkIdentity.Broadcast(Context, Args.Data); return true; } -void URemoteReducers::DeletePkString(const FString& S) +void URemoteReducers::InsertCallerUniqueConnectionId(const int32 Data) { if (!Conn) { @@ -5253,45 +8449,45 @@ void URemoteReducers::DeletePkString(const FString& S) return; } - FDeletePkStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkString(ReducerArgs)); } + FInsertCallerUniqueConnectionIdArgs ReducerArgs(Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_unique_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerUniqueConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkString(const FReducerEventContext& Context, const UDeletePkStringReducer* Args) +bool URemoteReducers::InvokeInsertCallerUniqueConnectionId(const FReducerEventContext& Context, const UInsertCallerUniqueConnectionIdReducer* Args) { - if (!OnDeletePkString.IsBound()) + if (!OnInsertCallerUniqueConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueConnectionId")); } return false; } - OnDeletePkString.Broadcast(Context, Args->S); + OnInsertCallerUniqueConnectionId.Broadcast(Context, Args->Data); return true; } -bool URemoteReducers::InvokeDeletePkStringWithArgs(const FReducerEventContext& Context, const FDeletePkStringArgs& Args) +bool URemoteReducers::InvokeInsertCallerUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerUniqueConnectionIdArgs& Args) { - if (!OnDeletePkString.IsBound()) + if (!OnInsertCallerUniqueConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueConnectionId")); } return false; } - OnDeletePkString.Broadcast(Context, Args.S); + OnInsertCallerUniqueConnectionId.Broadcast(Context, Args.Data); return true; } -void URemoteReducers::DeletePkU128(const FSpacetimeDBUInt128& N) +void URemoteReducers::InsertCallerUniqueIdentity(const int32 Data) { if (!Conn) { @@ -5299,45 +8495,45 @@ void URemoteReducers::DeletePkU128(const FSpacetimeDBUInt128& N) return; } - FDeletePkU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU128(ReducerArgs)); } + FInsertCallerUniqueIdentityArgs ReducerArgs(Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_unique_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerUniqueIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU128(const FReducerEventContext& Context, const UDeletePkU128Reducer* Args) +bool URemoteReducers::InvokeInsertCallerUniqueIdentity(const FReducerEventContext& Context, const UInsertCallerUniqueIdentityReducer* Args) { - if (!OnDeletePkU128.IsBound()) + if (!OnInsertCallerUniqueIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueIdentity")); } return false; } - OnDeletePkU128.Broadcast(Context, Args->N); + OnInsertCallerUniqueIdentity.Broadcast(Context, Args->Data); return true; } -bool URemoteReducers::InvokeDeletePkU128WithArgs(const FReducerEventContext& Context, const FDeletePkU128Args& Args) +bool URemoteReducers::InvokeInsertCallerUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerUniqueIdentityArgs& Args) { - if (!OnDeletePkU128.IsBound()) + if (!OnInsertCallerUniqueIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueIdentity")); } return false; } - OnDeletePkU128.Broadcast(Context, Args.N); + OnInsertCallerUniqueIdentity.Broadcast(Context, Args.Data); return true; } -void URemoteReducers::DeletePkU16(const uint16 N) +void URemoteReducers::InsertCallerVecConnectionId() { if (!Conn) { @@ -5345,45 +8541,45 @@ void URemoteReducers::DeletePkU16(const uint16 N) return; } - FDeletePkU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU16(ReducerArgs)); } + FInsertCallerVecConnectionIdArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_vec_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerVecConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU16(const FReducerEventContext& Context, const UDeletePkU16Reducer* Args) +bool URemoteReducers::InvokeInsertCallerVecConnectionId(const FReducerEventContext& Context, const UInsertCallerVecConnectionIdReducer* Args) { - if (!OnDeletePkU16.IsBound()) + if (!OnInsertCallerVecConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecConnectionId")); } return false; } - OnDeletePkU16.Broadcast(Context, Args->N); + OnInsertCallerVecConnectionId.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkU16WithArgs(const FReducerEventContext& Context, const FDeletePkU16Args& Args) +bool URemoteReducers::InvokeInsertCallerVecConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerVecConnectionIdArgs& Args) { - if (!OnDeletePkU16.IsBound()) + if (!OnInsertCallerVecConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecConnectionId")); } return false; } - OnDeletePkU16.Broadcast(Context, Args.N); + OnInsertCallerVecConnectionId.Broadcast(Context); return true; } -void URemoteReducers::DeletePkU256(const FSpacetimeDBUInt256& N) +void URemoteReducers::InsertCallerVecIdentity() { if (!Conn) { @@ -5391,45 +8587,45 @@ void URemoteReducers::DeletePkU256(const FSpacetimeDBUInt256& N) return; } - FDeletePkU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU256(ReducerArgs)); } + FInsertCallerVecIdentityArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_vec_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerVecIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU256(const FReducerEventContext& Context, const UDeletePkU256Reducer* Args) +bool URemoteReducers::InvokeInsertCallerVecIdentity(const FReducerEventContext& Context, const UInsertCallerVecIdentityReducer* Args) { - if (!OnDeletePkU256.IsBound()) + if (!OnInsertCallerVecIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecIdentity")); } return false; } - OnDeletePkU256.Broadcast(Context, Args->N); + OnInsertCallerVecIdentity.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkU256WithArgs(const FReducerEventContext& Context, const FDeletePkU256Args& Args) +bool URemoteReducers::InvokeInsertCallerVecIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerVecIdentityArgs& Args) { - if (!OnDeletePkU256.IsBound()) + if (!OnInsertCallerVecIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecIdentity")); } return false; } - OnDeletePkU256.Broadcast(Context, Args.N); + OnInsertCallerVecIdentity.Broadcast(Context); return true; } -void URemoteReducers::DeletePkU32(const uint32 N) +void URemoteReducers::InsertIntoBtreeU32(const TArray& Rows) { if (!Conn) { @@ -5437,45 +8633,45 @@ void URemoteReducers::DeletePkU32(const uint32 N) return; } - FDeletePkU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32(ReducerArgs)); } + FInsertIntoBtreeU32Args ReducerArgs(Rows); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_btree_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoBtreeU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU32(const FReducerEventContext& Context, const UDeletePkU32Reducer* Args) +bool URemoteReducers::InvokeInsertIntoBtreeU32(const FReducerEventContext& Context, const UInsertIntoBtreeU32Reducer* Args) { - if (!OnDeletePkU32.IsBound()) + if (!OnInsertIntoBtreeU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoBtreeU32")); } return false; } - OnDeletePkU32.Broadcast(Context, Args->N); + OnInsertIntoBtreeU32.Broadcast(Context, Args->Rows); return true; } -bool URemoteReducers::InvokeDeletePkU32WithArgs(const FReducerEventContext& Context, const FDeletePkU32Args& Args) +bool URemoteReducers::InvokeInsertIntoBtreeU32WithArgs(const FReducerEventContext& Context, const FInsertIntoBtreeU32Args& Args) { - if (!OnDeletePkU32.IsBound()) + if (!OnInsertIntoBtreeU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoBtreeU32")); } return false; } - OnDeletePkU32.Broadcast(Context, Args.N); + OnInsertIntoBtreeU32.Broadcast(Context, Args.Rows); return true; } -void URemoteReducers::DeletePkU32InsertPkU32Two(const uint32 N, const int32 Data) +void URemoteReducers::InsertIntoIndexedSimpleEnum(const ESimpleEnumType& N) { if (!Conn) { @@ -5483,45 +8679,45 @@ void URemoteReducers::DeletePkU32InsertPkU32Two(const uint32 N, const int32 Data return; } - FDeletePkU32InsertPkU32TwoArgs ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32_insert_pk_u_32_two"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32InsertPkU32Two(ReducerArgs)); } + FInsertIntoIndexedSimpleEnumArgs ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_indexed_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoIndexedSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU32InsertPkU32Two(const FReducerEventContext& Context, const UDeletePkU32InsertPkU32TwoReducer* Args) +bool URemoteReducers::InvokeInsertIntoIndexedSimpleEnum(const FReducerEventContext& Context, const UInsertIntoIndexedSimpleEnumReducer* Args) { - if (!OnDeletePkU32InsertPkU32Two.IsBound()) + if (!OnInsertIntoIndexedSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32InsertPkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoIndexedSimpleEnum")); } return false; } - OnDeletePkU32InsertPkU32Two.Broadcast(Context, Args->N, Args->Data); + OnInsertIntoIndexedSimpleEnum.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeletePkU32InsertPkU32TwoWithArgs(const FReducerEventContext& Context, const FDeletePkU32InsertPkU32TwoArgs& Args) +bool URemoteReducers::InvokeInsertIntoIndexedSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertIntoIndexedSimpleEnumArgs& Args) { - if (!OnDeletePkU32InsertPkU32Two.IsBound()) + if (!OnInsertIntoIndexedSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32InsertPkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoIndexedSimpleEnum")); } return false; } - OnDeletePkU32InsertPkU32Two.Broadcast(Context, Args.N, Args.Data); + OnInsertIntoIndexedSimpleEnum.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeletePkU32Two(const uint32 N) +void URemoteReducers::InsertIntoPkBtreeU32(const TArray& PkU32, const TArray& BtU32) { if (!Conn) { @@ -5529,45 +8725,45 @@ void URemoteReducers::DeletePkU32Two(const uint32 N) return; } - FDeletePkU32TwoArgs ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32_two"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32Two(ReducerArgs)); } + FInsertIntoPkBtreeU32Args ReducerArgs(PkU32, BtU32); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_pk_btree_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoPkBtreeU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU32Two(const FReducerEventContext& Context, const UDeletePkU32TwoReducer* Args) +bool URemoteReducers::InvokeInsertIntoPkBtreeU32(const FReducerEventContext& Context, const UInsertIntoPkBtreeU32Reducer* Args) { - if (!OnDeletePkU32Two.IsBound()) + if (!OnInsertIntoPkBtreeU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoPkBtreeU32")); } return false; } - OnDeletePkU32Two.Broadcast(Context, Args->N); + OnInsertIntoPkBtreeU32.Broadcast(Context, Args->PkU32, Args->BtU32); return true; } -bool URemoteReducers::InvokeDeletePkU32TwoWithArgs(const FReducerEventContext& Context, const FDeletePkU32TwoArgs& Args) +bool URemoteReducers::InvokeInsertIntoPkBtreeU32WithArgs(const FReducerEventContext& Context, const FInsertIntoPkBtreeU32Args& Args) { - if (!OnDeletePkU32Two.IsBound()) + if (!OnInsertIntoPkBtreeU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoPkBtreeU32")); } return false; } - OnDeletePkU32Two.Broadcast(Context, Args.N); + OnInsertIntoPkBtreeU32.Broadcast(Context, Args.PkU32, Args.BtU32); return true; } -void URemoteReducers::DeletePkU64(const uint64 N) +void URemoteReducers::InsertLargeTable(const uint8 A, const uint16 B, const uint32 C, const uint64 D, const FSpacetimeDBUInt128& E, const FSpacetimeDBUInt256& F, const int8 G, const int16 H, const int32 I, const int64 J, const FSpacetimeDBInt128& K, const FSpacetimeDBInt256& L, const bool M, const float N, const double O, const FString& P, const ESimpleEnumType& Q, const FEnumWithPayloadType& R, const FUnitStructType& S, const FByteStructType& T, const FEveryPrimitiveStructType& U, const FEveryVecStructType& V) { if (!Conn) { @@ -5575,45 +8771,68 @@ void URemoteReducers::DeletePkU64(const uint64 N) return; } - FDeletePkU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU64(ReducerArgs)); } + FInsertLargeTableArgs ReducerArgs(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_large_table"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertLargeTable(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU64(const FReducerEventContext& Context, const UDeletePkU64Reducer* Args) +bool URemoteReducers::InvokeInsertLargeTable(const FReducerEventContext& Context, const UInsertLargeTableReducer* Args) { - if (!OnDeletePkU64.IsBound()) + if (!OnInsertLargeTable.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertLargeTable")); } return false; } - OnDeletePkU64.Broadcast(Context, Args->N); + FInsertLargeTableArgs ArgsStruct; + ArgsStruct.A = Args->A; + ArgsStruct.B = Args->B; + ArgsStruct.C = Args->C; + ArgsStruct.D = Args->D; + ArgsStruct.E = Args->E; + ArgsStruct.F = Args->F; + ArgsStruct.G = Args->G; + ArgsStruct.H = Args->H; + ArgsStruct.I = Args->I; + ArgsStruct.J = Args->J; + ArgsStruct.K = Args->K; + ArgsStruct.L = Args->L; + ArgsStruct.M = Args->M; + ArgsStruct.N = Args->N; + ArgsStruct.O = Args->O; + ArgsStruct.P = Args->P; + ArgsStruct.Q = Args->Q; + ArgsStruct.R = Args->R; + ArgsStruct.S = Args->S; + ArgsStruct.T = Args->T; + ArgsStruct.U = Args->U; + ArgsStruct.V = Args->V; + OnInsertLargeTable.Broadcast(Context, ArgsStruct); return true; } -bool URemoteReducers::InvokeDeletePkU64WithArgs(const FReducerEventContext& Context, const FDeletePkU64Args& Args) +bool URemoteReducers::InvokeInsertLargeTableWithArgs(const FReducerEventContext& Context, const FInsertLargeTableArgs& Args) { - if (!OnDeletePkU64.IsBound()) + if (!OnInsertLargeTable.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertLargeTable")); } return false; } - OnDeletePkU64.Broadcast(Context, Args.N); + OnInsertLargeTable.Broadcast(Context, Args); return true; } -void URemoteReducers::DeletePkU8(const uint8 N) +void URemoteReducers::InsertOneBool(const bool B) { if (!Conn) { @@ -5621,45 +8840,45 @@ void URemoteReducers::DeletePkU8(const uint8 N) return; } - FDeletePkU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU8(ReducerArgs)); } + FInsertOneBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneBool(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU8(const FReducerEventContext& Context, const UDeletePkU8Reducer* Args) +bool URemoteReducers::InvokeInsertOneBool(const FReducerEventContext& Context, const UInsertOneBoolReducer* Args) { - if (!OnDeletePkU8.IsBound()) + if (!OnInsertOneBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneBool")); } return false; } - OnDeletePkU8.Broadcast(Context, Args->N); + OnInsertOneBool.Broadcast(Context, Args->B); return true; } -bool URemoteReducers::InvokeDeletePkU8WithArgs(const FReducerEventContext& Context, const FDeletePkU8Args& Args) +bool URemoteReducers::InvokeInsertOneBoolWithArgs(const FReducerEventContext& Context, const FInsertOneBoolArgs& Args) { - if (!OnDeletePkU8.IsBound()) + if (!OnInsertOneBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneBool")); } return false; } - OnDeletePkU8.Broadcast(Context, Args.N); + OnInsertOneBool.Broadcast(Context, Args.B); return true; } -void URemoteReducers::DeletePkUuid(const FSpacetimeDBUuid& U) +void URemoteReducers::InsertOneByteStruct(const FByteStructType& S) { if (!Conn) { @@ -5667,45 +8886,45 @@ void URemoteReducers::DeletePkUuid(const FSpacetimeDBUuid& U) return; } - FDeletePkUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkUuid(ReducerArgs)); } + FInsertOneByteStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_byte_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneByteStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkUuid(const FReducerEventContext& Context, const UDeletePkUuidReducer* Args) +bool URemoteReducers::InvokeInsertOneByteStruct(const FReducerEventContext& Context, const UInsertOneByteStructReducer* Args) { - if (!OnDeletePkUuid.IsBound()) + if (!OnInsertOneByteStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneByteStruct")); } return false; } - OnDeletePkUuid.Broadcast(Context, Args->U); + OnInsertOneByteStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeletePkUuidWithArgs(const FReducerEventContext& Context, const FDeletePkUuidArgs& Args) +bool URemoteReducers::InvokeInsertOneByteStructWithArgs(const FReducerEventContext& Context, const FInsertOneByteStructArgs& Args) { - if (!OnDeletePkUuid.IsBound()) + if (!OnInsertOneByteStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneByteStruct")); } return false; } - OnDeletePkUuid.Broadcast(Context, Args.U); + OnInsertOneByteStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteUniqueBool(const bool B) +void URemoteReducers::InsertOneConnectionId(const FSpacetimeDBConnectionId& A) { if (!Conn) { @@ -5713,45 +8932,45 @@ void URemoteReducers::DeleteUniqueBool(const bool B) return; } - FDeleteUniqueBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueBool(ReducerArgs)); } + FInsertOneConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueBool(const FReducerEventContext& Context, const UDeleteUniqueBoolReducer* Args) +bool URemoteReducers::InvokeInsertOneConnectionId(const FReducerEventContext& Context, const UInsertOneConnectionIdReducer* Args) { - if (!OnDeleteUniqueBool.IsBound()) + if (!OnInsertOneConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneConnectionId")); } return false; } - OnDeleteUniqueBool.Broadcast(Context, Args->B); + OnInsertOneConnectionId.Broadcast(Context, Args->A); return true; } -bool URemoteReducers::InvokeDeleteUniqueBoolWithArgs(const FReducerEventContext& Context, const FDeleteUniqueBoolArgs& Args) +bool URemoteReducers::InvokeInsertOneConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertOneConnectionIdArgs& Args) { - if (!OnDeleteUniqueBool.IsBound()) + if (!OnInsertOneConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneConnectionId")); } return false; } - OnDeleteUniqueBool.Broadcast(Context, Args.B); + OnInsertOneConnectionId.Broadcast(Context, Args.A); return true; } -void URemoteReducers::DeleteUniqueConnectionId(const FSpacetimeDBConnectionId& A) +void URemoteReducers::InsertOneEnumWithPayload(const FEnumWithPayloadType& E) { if (!Conn) { @@ -5759,45 +8978,45 @@ void URemoteReducers::DeleteUniqueConnectionId(const FSpacetimeDBConnectionId& A return; } - FDeleteUniqueConnectionIdArgs ReducerArgs(A); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueConnectionId(ReducerArgs)); } + FInsertOneEnumWithPayloadArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_enum_with_payload"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEnumWithPayload(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueConnectionId(const FReducerEventContext& Context, const UDeleteUniqueConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOneEnumWithPayload(const FReducerEventContext& Context, const UInsertOneEnumWithPayloadReducer* Args) { - if (!OnDeleteUniqueConnectionId.IsBound()) + if (!OnInsertOneEnumWithPayload.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEnumWithPayload")); } return false; } - OnDeleteUniqueConnectionId.Broadcast(Context, Args->A); + OnInsertOneEnumWithPayload.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeDeleteUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteUniqueConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOneEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FInsertOneEnumWithPayloadArgs& Args) { - if (!OnDeleteUniqueConnectionId.IsBound()) + if (!OnInsertOneEnumWithPayload.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEnumWithPayload")); } return false; } - OnDeleteUniqueConnectionId.Broadcast(Context, Args.A); + OnInsertOneEnumWithPayload.Broadcast(Context, Args.E); return true; } -void URemoteReducers::DeleteUniqueI128(const FSpacetimeDBInt128& N) +void URemoteReducers::InsertOneEveryPrimitiveStruct(const FEveryPrimitiveStructType& S) { if (!Conn) { @@ -5805,45 +9024,45 @@ void URemoteReducers::DeleteUniqueI128(const FSpacetimeDBInt128& N) return; } - FDeleteUniqueI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI128(ReducerArgs)); } + FInsertOneEveryPrimitiveStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_every_primitive_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEveryPrimitiveStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI128(const FReducerEventContext& Context, const UDeleteUniqueI128Reducer* Args) +bool URemoteReducers::InvokeInsertOneEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertOneEveryPrimitiveStructReducer* Args) { - if (!OnDeleteUniqueI128.IsBound()) + if (!OnInsertOneEveryPrimitiveStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryPrimitiveStruct")); } return false; } - OnDeleteUniqueI128.Broadcast(Context, Args->N); + OnInsertOneEveryPrimitiveStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteUniqueI128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI128Args& Args) +bool URemoteReducers::InvokeInsertOneEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertOneEveryPrimitiveStructArgs& Args) { - if (!OnDeleteUniqueI128.IsBound()) + if (!OnInsertOneEveryPrimitiveStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryPrimitiveStruct")); } return false; } - OnDeleteUniqueI128.Broadcast(Context, Args.N); + OnInsertOneEveryPrimitiveStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteUniqueI16(const int16 N) +void URemoteReducers::InsertOneEveryVecStruct(const FEveryVecStructType& S) { if (!Conn) { @@ -5851,45 +9070,45 @@ void URemoteReducers::DeleteUniqueI16(const int16 N) return; } - FDeleteUniqueI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI16(ReducerArgs)); } + FInsertOneEveryVecStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_every_vec_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEveryVecStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI16(const FReducerEventContext& Context, const UDeleteUniqueI16Reducer* Args) +bool URemoteReducers::InvokeInsertOneEveryVecStruct(const FReducerEventContext& Context, const UInsertOneEveryVecStructReducer* Args) { - if (!OnDeleteUniqueI16.IsBound()) + if (!OnInsertOneEveryVecStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryVecStruct")); } return false; } - OnDeleteUniqueI16.Broadcast(Context, Args->N); + OnInsertOneEveryVecStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteUniqueI16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI16Args& Args) +bool URemoteReducers::InvokeInsertOneEveryVecStructWithArgs(const FReducerEventContext& Context, const FInsertOneEveryVecStructArgs& Args) { - if (!OnDeleteUniqueI16.IsBound()) + if (!OnInsertOneEveryVecStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryVecStruct")); } return false; } - OnDeleteUniqueI16.Broadcast(Context, Args.N); + OnInsertOneEveryVecStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteUniqueI256(const FSpacetimeDBInt256& N) +void URemoteReducers::InsertOneF32(const float F) { if (!Conn) { @@ -5897,45 +9116,45 @@ void URemoteReducers::DeleteUniqueI256(const FSpacetimeDBInt256& N) return; } - FDeleteUniqueI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI256(ReducerArgs)); } + FInsertOneF32Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_f_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneF32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI256(const FReducerEventContext& Context, const UDeleteUniqueI256Reducer* Args) +bool URemoteReducers::InvokeInsertOneF32(const FReducerEventContext& Context, const UInsertOneF32Reducer* Args) { - if (!OnDeleteUniqueI256.IsBound()) + if (!OnInsertOneF32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF32")); } return false; } - OnDeleteUniqueI256.Broadcast(Context, Args->N); + OnInsertOneF32.Broadcast(Context, Args->F); return true; } -bool URemoteReducers::InvokeDeleteUniqueI256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI256Args& Args) +bool URemoteReducers::InvokeInsertOneF32WithArgs(const FReducerEventContext& Context, const FInsertOneF32Args& Args) { - if (!OnDeleteUniqueI256.IsBound()) + if (!OnInsertOneF32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF32")); } return false; } - OnDeleteUniqueI256.Broadcast(Context, Args.N); + OnInsertOneF32.Broadcast(Context, Args.F); return true; } -void URemoteReducers::DeleteUniqueI32(const int32 N) +void URemoteReducers::InsertOneF64(const double F) { if (!Conn) { @@ -5943,45 +9162,45 @@ void URemoteReducers::DeleteUniqueI32(const int32 N) return; } - FDeleteUniqueI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI32(ReducerArgs)); } + FInsertOneF64Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_f_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneF64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI32(const FReducerEventContext& Context, const UDeleteUniqueI32Reducer* Args) +bool URemoteReducers::InvokeInsertOneF64(const FReducerEventContext& Context, const UInsertOneF64Reducer* Args) { - if (!OnDeleteUniqueI32.IsBound()) + if (!OnInsertOneF64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF64")); } return false; } - OnDeleteUniqueI32.Broadcast(Context, Args->N); + OnInsertOneF64.Broadcast(Context, Args->F); return true; } -bool URemoteReducers::InvokeDeleteUniqueI32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI32Args& Args) +bool URemoteReducers::InvokeInsertOneF64WithArgs(const FReducerEventContext& Context, const FInsertOneF64Args& Args) { - if (!OnDeleteUniqueI32.IsBound()) + if (!OnInsertOneF64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF64")); } return false; } - OnDeleteUniqueI32.Broadcast(Context, Args.N); + OnInsertOneF64.Broadcast(Context, Args.F); return true; } -void URemoteReducers::DeleteUniqueI64(const int64 N) +void URemoteReducers::InsertOneI128(const FSpacetimeDBInt128& N) { if (!Conn) { @@ -5989,45 +9208,45 @@ void URemoteReducers::DeleteUniqueI64(const int64 N) return; } - FDeleteUniqueI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI64(ReducerArgs)); } + FInsertOneI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI64(const FReducerEventContext& Context, const UDeleteUniqueI64Reducer* Args) +bool URemoteReducers::InvokeInsertOneI128(const FReducerEventContext& Context, const UInsertOneI128Reducer* Args) { - if (!OnDeleteUniqueI64.IsBound()) + if (!OnInsertOneI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI128")); } return false; } - OnDeleteUniqueI64.Broadcast(Context, Args->N); + OnInsertOneI128.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueI64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI64Args& Args) +bool URemoteReducers::InvokeInsertOneI128WithArgs(const FReducerEventContext& Context, const FInsertOneI128Args& Args) { - if (!OnDeleteUniqueI64.IsBound()) + if (!OnInsertOneI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI128")); } return false; } - OnDeleteUniqueI64.Broadcast(Context, Args.N); + OnInsertOneI128.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueI8(const int8 N) +void URemoteReducers::InsertOneI16(const int16 N) { if (!Conn) { @@ -6035,45 +9254,45 @@ void URemoteReducers::DeleteUniqueI8(const int8 N) return; } - FDeleteUniqueI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI8(ReducerArgs)); } + FInsertOneI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI16(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI8(const FReducerEventContext& Context, const UDeleteUniqueI8Reducer* Args) +bool URemoteReducers::InvokeInsertOneI16(const FReducerEventContext& Context, const UInsertOneI16Reducer* Args) { - if (!OnDeleteUniqueI8.IsBound()) + if (!OnInsertOneI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI16")); } return false; } - OnDeleteUniqueI8.Broadcast(Context, Args->N); + OnInsertOneI16.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueI8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI8Args& Args) +bool URemoteReducers::InvokeInsertOneI16WithArgs(const FReducerEventContext& Context, const FInsertOneI16Args& Args) { - if (!OnDeleteUniqueI8.IsBound()) + if (!OnInsertOneI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI16")); } return false; } - OnDeleteUniqueI8.Broadcast(Context, Args.N); + OnInsertOneI16.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueIdentity(const FSpacetimeDBIdentity& I) +void URemoteReducers::InsertOneI256(const FSpacetimeDBInt256& N) { if (!Conn) { @@ -6081,45 +9300,45 @@ void URemoteReducers::DeleteUniqueIdentity(const FSpacetimeDBIdentity& I) return; } - FDeleteUniqueIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueIdentity(ReducerArgs)); } + FInsertOneI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueIdentity(const FReducerEventContext& Context, const UDeleteUniqueIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOneI256(const FReducerEventContext& Context, const UInsertOneI256Reducer* Args) { - if (!OnDeleteUniqueIdentity.IsBound()) + if (!OnInsertOneI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI256")); } return false; } - OnDeleteUniqueIdentity.Broadcast(Context, Args->I); + OnInsertOneI256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOneI256WithArgs(const FReducerEventContext& Context, const FInsertOneI256Args& Args) { - if (!OnDeleteUniqueIdentity.IsBound()) + if (!OnInsertOneI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI256")); } return false; } - OnDeleteUniqueIdentity.Broadcast(Context, Args.I); + OnInsertOneI256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueString(const FString& S) +void URemoteReducers::InsertOneI32(const int32 N) { if (!Conn) { @@ -6127,45 +9346,45 @@ void URemoteReducers::DeleteUniqueString(const FString& S) return; } - FDeleteUniqueStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueString(ReducerArgs)); } + FInsertOneI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueString(const FReducerEventContext& Context, const UDeleteUniqueStringReducer* Args) +bool URemoteReducers::InvokeInsertOneI32(const FReducerEventContext& Context, const UInsertOneI32Reducer* Args) { - if (!OnDeleteUniqueString.IsBound()) + if (!OnInsertOneI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI32")); } return false; } - OnDeleteUniqueString.Broadcast(Context, Args->S); + OnInsertOneI32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueStringArgs& Args) +bool URemoteReducers::InvokeInsertOneI32WithArgs(const FReducerEventContext& Context, const FInsertOneI32Args& Args) { - if (!OnDeleteUniqueString.IsBound()) + if (!OnInsertOneI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI32")); } return false; } - OnDeleteUniqueString.Broadcast(Context, Args.S); + OnInsertOneI32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueU128(const FSpacetimeDBUInt128& N) +void URemoteReducers::InsertOneI64(const int64 N) { if (!Conn) { @@ -6173,45 +9392,45 @@ void URemoteReducers::DeleteUniqueU128(const FSpacetimeDBUInt128& N) return; } - FDeleteUniqueU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU128(ReducerArgs)); } + FInsertOneI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU128(const FReducerEventContext& Context, const UDeleteUniqueU128Reducer* Args) +bool URemoteReducers::InvokeInsertOneI64(const FReducerEventContext& Context, const UInsertOneI64Reducer* Args) { - if (!OnDeleteUniqueU128.IsBound()) + if (!OnInsertOneI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI64")); } return false; } - OnDeleteUniqueU128.Broadcast(Context, Args->N); + OnInsertOneI64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU128Args& Args) +bool URemoteReducers::InvokeInsertOneI64WithArgs(const FReducerEventContext& Context, const FInsertOneI64Args& Args) { - if (!OnDeleteUniqueU128.IsBound()) + if (!OnInsertOneI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI64")); } return false; } - OnDeleteUniqueU128.Broadcast(Context, Args.N); + OnInsertOneI64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueU16(const uint16 N) +void URemoteReducers::InsertOneI8(const int8 N) { if (!Conn) { @@ -6219,45 +9438,45 @@ void URemoteReducers::DeleteUniqueU16(const uint16 N) return; } - FDeleteUniqueU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU16(ReducerArgs)); } + FInsertOneI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU16(const FReducerEventContext& Context, const UDeleteUniqueU16Reducer* Args) +bool URemoteReducers::InvokeInsertOneI8(const FReducerEventContext& Context, const UInsertOneI8Reducer* Args) { - if (!OnDeleteUniqueU16.IsBound()) + if (!OnInsertOneI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI8")); } return false; } - OnDeleteUniqueU16.Broadcast(Context, Args->N); + OnInsertOneI8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU16Args& Args) +bool URemoteReducers::InvokeInsertOneI8WithArgs(const FReducerEventContext& Context, const FInsertOneI8Args& Args) { - if (!OnDeleteUniqueU16.IsBound()) + if (!OnInsertOneI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI8")); } return false; } - OnDeleteUniqueU16.Broadcast(Context, Args.N); + OnInsertOneI8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueU256(const FSpacetimeDBUInt256& N) +void URemoteReducers::InsertOneIdentity(const FSpacetimeDBIdentity& I) { if (!Conn) { @@ -6265,45 +9484,45 @@ void URemoteReducers::DeleteUniqueU256(const FSpacetimeDBUInt256& N) return; } - FDeleteUniqueU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU256(ReducerArgs)); } + FInsertOneIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU256(const FReducerEventContext& Context, const UDeleteUniqueU256Reducer* Args) +bool URemoteReducers::InvokeInsertOneIdentity(const FReducerEventContext& Context, const UInsertOneIdentityReducer* Args) { - if (!OnDeleteUniqueU256.IsBound()) + if (!OnInsertOneIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneIdentity")); } return false; } - OnDeleteUniqueU256.Broadcast(Context, Args->N); + OnInsertOneIdentity.Broadcast(Context, Args->I); return true; } -bool URemoteReducers::InvokeDeleteUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU256Args& Args) +bool URemoteReducers::InvokeInsertOneIdentityWithArgs(const FReducerEventContext& Context, const FInsertOneIdentityArgs& Args) { - if (!OnDeleteUniqueU256.IsBound()) + if (!OnInsertOneIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneIdentity")); } return false; } - OnDeleteUniqueU256.Broadcast(Context, Args.N); + OnInsertOneIdentity.Broadcast(Context, Args.I); return true; } -void URemoteReducers::DeleteUniqueU32(const uint32 N) +void URemoteReducers::InsertOneSimpleEnum(const ESimpleEnumType& E) { if (!Conn) { @@ -6311,45 +9530,45 @@ void URemoteReducers::DeleteUniqueU32(const uint32 N) return; } - FDeleteUniqueU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU32(ReducerArgs)); } + FInsertOneSimpleEnumArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU32(const FReducerEventContext& Context, const UDeleteUniqueU32Reducer* Args) +bool URemoteReducers::InvokeInsertOneSimpleEnum(const FReducerEventContext& Context, const UInsertOneSimpleEnumReducer* Args) { - if (!OnDeleteUniqueU32.IsBound()) + if (!OnInsertOneSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneSimpleEnum")); } return false; } - OnDeleteUniqueU32.Broadcast(Context, Args->N); + OnInsertOneSimpleEnum.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeDeleteUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU32Args& Args) +bool URemoteReducers::InvokeInsertOneSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertOneSimpleEnumArgs& Args) { - if (!OnDeleteUniqueU32.IsBound()) + if (!OnInsertOneSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneSimpleEnum")); } return false; } - OnDeleteUniqueU32.Broadcast(Context, Args.N); + OnInsertOneSimpleEnum.Broadcast(Context, Args.E); return true; } -void URemoteReducers::DeleteUniqueU64(const uint64 N) +void URemoteReducers::InsertOneString(const FString& S) { if (!Conn) { @@ -6357,45 +9576,45 @@ void URemoteReducers::DeleteUniqueU64(const uint64 N) return; } - FDeleteUniqueU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU64(ReducerArgs)); } + FInsertOneStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneString(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU64(const FReducerEventContext& Context, const UDeleteUniqueU64Reducer* Args) +bool URemoteReducers::InvokeInsertOneString(const FReducerEventContext& Context, const UInsertOneStringReducer* Args) { - if (!OnDeleteUniqueU64.IsBound()) + if (!OnInsertOneString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneString")); } return false; } - OnDeleteUniqueU64.Broadcast(Context, Args->N); + OnInsertOneString.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU64Args& Args) +bool URemoteReducers::InvokeInsertOneStringWithArgs(const FReducerEventContext& Context, const FInsertOneStringArgs& Args) { - if (!OnDeleteUniqueU64.IsBound()) + if (!OnInsertOneString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneString")); } return false; } - OnDeleteUniqueU64.Broadcast(Context, Args.N); + OnInsertOneString.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteUniqueU8(const uint8 N) +void URemoteReducers::InsertOneTimestamp(const FSpacetimeDBTimestamp& T) { if (!Conn) { @@ -6403,45 +9622,45 @@ void URemoteReducers::DeleteUniqueU8(const uint8 N) return; } - FDeleteUniqueU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU8(ReducerArgs)); } + FInsertOneTimestampArgs ReducerArgs(T); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_timestamp"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneTimestamp(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU8(const FReducerEventContext& Context, const UDeleteUniqueU8Reducer* Args) +bool URemoteReducers::InvokeInsertOneTimestamp(const FReducerEventContext& Context, const UInsertOneTimestampReducer* Args) { - if (!OnDeleteUniqueU8.IsBound()) + if (!OnInsertOneTimestamp.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneTimestamp")); } return false; } - OnDeleteUniqueU8.Broadcast(Context, Args->N); + OnInsertOneTimestamp.Broadcast(Context, Args->T); return true; } -bool URemoteReducers::InvokeDeleteUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU8Args& Args) +bool URemoteReducers::InvokeInsertOneTimestampWithArgs(const FReducerEventContext& Context, const FInsertOneTimestampArgs& Args) { - if (!OnDeleteUniqueU8.IsBound()) + if (!OnInsertOneTimestamp.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneTimestamp")); } return false; } - OnDeleteUniqueU8.Broadcast(Context, Args.N); + OnInsertOneTimestamp.Broadcast(Context, Args.T); return true; } -void URemoteReducers::DeleteUniqueUuid(const FSpacetimeDBUuid& U) +void URemoteReducers::InsertOneU128(const FSpacetimeDBUInt128& N) { if (!Conn) { @@ -6449,45 +9668,45 @@ void URemoteReducers::DeleteUniqueUuid(const FSpacetimeDBUuid& U) return; } - FDeleteUniqueUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueUuid(ReducerArgs)); } + FInsertOneU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueUuid(const FReducerEventContext& Context, const UDeleteUniqueUuidReducer* Args) +bool URemoteReducers::InvokeInsertOneU128(const FReducerEventContext& Context, const UInsertOneU128Reducer* Args) { - if (!OnDeleteUniqueUuid.IsBound()) + if (!OnInsertOneU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU128")); } return false; } - OnDeleteUniqueUuid.Broadcast(Context, Args->U); + OnInsertOneU128.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueUuidArgs& Args) +bool URemoteReducers::InvokeInsertOneU128WithArgs(const FReducerEventContext& Context, const FInsertOneU128Args& Args) { - if (!OnDeleteUniqueUuid.IsBound()) + if (!OnInsertOneU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU128")); } return false; } - OnDeleteUniqueUuid.Broadcast(Context, Args.U); + OnInsertOneU128.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallTimestamp() +void URemoteReducers::InsertOneU16(const uint16 N) { if (!Conn) { @@ -6495,45 +9714,45 @@ void URemoteReducers::InsertCallTimestamp() return; } - FInsertCallTimestampArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_timestamp"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallTimestamp(ReducerArgs)); } + FInsertOneU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallTimestamp(const FReducerEventContext& Context, const UInsertCallTimestampReducer* Args) +bool URemoteReducers::InvokeInsertOneU16(const FReducerEventContext& Context, const UInsertOneU16Reducer* Args) { - if (!OnInsertCallTimestamp.IsBound()) + if (!OnInsertOneU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU16")); } return false; } - OnInsertCallTimestamp.Broadcast(Context); + OnInsertOneU16.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallTimestampWithArgs(const FReducerEventContext& Context, const FInsertCallTimestampArgs& Args) +bool URemoteReducers::InvokeInsertOneU16WithArgs(const FReducerEventContext& Context, const FInsertOneU16Args& Args) { - if (!OnInsertCallTimestamp.IsBound()) + if (!OnInsertOneU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU16")); } return false; } - OnInsertCallTimestamp.Broadcast(Context); + OnInsertOneU16.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallUuidV4() +void URemoteReducers::InsertOneU256(const FSpacetimeDBUInt256& N) { if (!Conn) { @@ -6541,45 +9760,45 @@ void URemoteReducers::InsertCallUuidV4() return; } - FInsertCallUuidV4Args ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_uuid_v_4"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallUuidV4(ReducerArgs)); } + FInsertOneU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallUuidV4(const FReducerEventContext& Context, const UInsertCallUuidV4Reducer* Args) +bool URemoteReducers::InvokeInsertOneU256(const FReducerEventContext& Context, const UInsertOneU256Reducer* Args) { - if (!OnInsertCallUuidV4.IsBound()) + if (!OnInsertOneU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV4")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU256")); } return false; } - OnInsertCallUuidV4.Broadcast(Context); + OnInsertOneU256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallUuidV4WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV4Args& Args) +bool URemoteReducers::InvokeInsertOneU256WithArgs(const FReducerEventContext& Context, const FInsertOneU256Args& Args) { - if (!OnInsertCallUuidV4.IsBound()) + if (!OnInsertOneU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV4")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU256")); } return false; } - OnInsertCallUuidV4.Broadcast(Context); + OnInsertOneU256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallUuidV7() +void URemoteReducers::InsertOneU32(const uint32 N) { if (!Conn) { @@ -6587,45 +9806,45 @@ void URemoteReducers::InsertCallUuidV7() return; } - FInsertCallUuidV7Args ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_uuid_v_7"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallUuidV7(ReducerArgs)); } + FInsertOneU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallUuidV7(const FReducerEventContext& Context, const UInsertCallUuidV7Reducer* Args) +bool URemoteReducers::InvokeInsertOneU32(const FReducerEventContext& Context, const UInsertOneU32Reducer* Args) { - if (!OnInsertCallUuidV7.IsBound()) + if (!OnInsertOneU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV7")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU32")); } return false; } - OnInsertCallUuidV7.Broadcast(Context); + OnInsertOneU32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallUuidV7WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV7Args& Args) +bool URemoteReducers::InvokeInsertOneU32WithArgs(const FReducerEventContext& Context, const FInsertOneU32Args& Args) { - if (!OnInsertCallUuidV7.IsBound()) + if (!OnInsertOneU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV7")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU32")); } return false; } - OnInsertCallUuidV7.Broadcast(Context); + OnInsertOneU32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallerOneConnectionId() +void URemoteReducers::InsertOneU64(const uint64 N) { if (!Conn) { @@ -6633,45 +9852,45 @@ void URemoteReducers::InsertCallerOneConnectionId() return; } - FInsertCallerOneConnectionIdArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_one_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerOneConnectionId(ReducerArgs)); } + FInsertOneU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerOneConnectionId(const FReducerEventContext& Context, const UInsertCallerOneConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOneU64(const FReducerEventContext& Context, const UInsertOneU64Reducer* Args) { - if (!OnInsertCallerOneConnectionId.IsBound()) + if (!OnInsertOneU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU64")); } return false; } - OnInsertCallerOneConnectionId.Broadcast(Context); + OnInsertOneU64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallerOneConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerOneConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOneU64WithArgs(const FReducerEventContext& Context, const FInsertOneU64Args& Args) { - if (!OnInsertCallerOneConnectionId.IsBound()) + if (!OnInsertOneU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU64")); } return false; } - OnInsertCallerOneConnectionId.Broadcast(Context); + OnInsertOneU64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallerOneIdentity() +void URemoteReducers::InsertOneU8(const uint8 N) { if (!Conn) { @@ -6679,45 +9898,45 @@ void URemoteReducers::InsertCallerOneIdentity() return; } - FInsertCallerOneIdentityArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_one_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerOneIdentity(ReducerArgs)); } + FInsertOneU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerOneIdentity(const FReducerEventContext& Context, const UInsertCallerOneIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOneU8(const FReducerEventContext& Context, const UInsertOneU8Reducer* Args) { - if (!OnInsertCallerOneIdentity.IsBound()) + if (!OnInsertOneU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU8")); } return false; } - OnInsertCallerOneIdentity.Broadcast(Context); + OnInsertOneU8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallerOneIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerOneIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOneU8WithArgs(const FReducerEventContext& Context, const FInsertOneU8Args& Args) { - if (!OnInsertCallerOneIdentity.IsBound()) + if (!OnInsertOneU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU8")); } return false; } - OnInsertCallerOneIdentity.Broadcast(Context); + OnInsertOneU8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallerPkConnectionId(const int32 Data) +void URemoteReducers::InsertOneUnitStruct(const FUnitStructType& S) { if (!Conn) { @@ -6725,45 +9944,45 @@ void URemoteReducers::InsertCallerPkConnectionId(const int32 Data) return; } - FInsertCallerPkConnectionIdArgs ReducerArgs(Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_pk_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerPkConnectionId(ReducerArgs)); } + FInsertOneUnitStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_unit_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneUnitStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerPkConnectionId(const FReducerEventContext& Context, const UInsertCallerPkConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOneUnitStruct(const FReducerEventContext& Context, const UInsertOneUnitStructReducer* Args) { - if (!OnInsertCallerPkConnectionId.IsBound()) + if (!OnInsertOneUnitStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUnitStruct")); } return false; } - OnInsertCallerPkConnectionId.Broadcast(Context, Args->Data); + OnInsertOneUnitStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertCallerPkConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerPkConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOneUnitStructWithArgs(const FReducerEventContext& Context, const FInsertOneUnitStructArgs& Args) { - if (!OnInsertCallerPkConnectionId.IsBound()) + if (!OnInsertOneUnitStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUnitStruct")); } return false; } - OnInsertCallerPkConnectionId.Broadcast(Context, Args.Data); + OnInsertOneUnitStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertCallerPkIdentity(const int32 Data) +void URemoteReducers::InsertOneUuid(const FSpacetimeDBUuid& U) { if (!Conn) { @@ -6771,45 +9990,45 @@ void URemoteReducers::InsertCallerPkIdentity(const int32 Data) return; } - FInsertCallerPkIdentityArgs ReducerArgs(Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_pk_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerPkIdentity(ReducerArgs)); } + FInsertOneUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerPkIdentity(const FReducerEventContext& Context, const UInsertCallerPkIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOneUuid(const FReducerEventContext& Context, const UInsertOneUuidReducer* Args) { - if (!OnInsertCallerPkIdentity.IsBound()) + if (!OnInsertOneUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUuid")); } return false; } - OnInsertCallerPkIdentity.Broadcast(Context, Args->Data); + OnInsertOneUuid.Broadcast(Context, Args->U); return true; } -bool URemoteReducers::InvokeInsertCallerPkIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerPkIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOneUuidWithArgs(const FReducerEventContext& Context, const FInsertOneUuidArgs& Args) { - if (!OnInsertCallerPkIdentity.IsBound()) + if (!OnInsertOneUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUuid")); } return false; } - OnInsertCallerPkIdentity.Broadcast(Context, Args.Data); + OnInsertOneUuid.Broadcast(Context, Args.U); return true; } -void URemoteReducers::InsertCallerUniqueConnectionId(const int32 Data) +void URemoteReducers::InsertOptionEveryPrimitiveStruct(const FTestClientOptionalEveryPrimitiveStruct& S) { if (!Conn) { @@ -6817,45 +10036,45 @@ void URemoteReducers::InsertCallerUniqueConnectionId(const int32 Data) return; } - FInsertCallerUniqueConnectionIdArgs ReducerArgs(Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_unique_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerUniqueConnectionId(ReducerArgs)); } + FInsertOptionEveryPrimitiveStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_every_primitive_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionEveryPrimitiveStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerUniqueConnectionId(const FReducerEventContext& Context, const UInsertCallerUniqueConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOptionEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertOptionEveryPrimitiveStructReducer* Args) { - if (!OnInsertCallerUniqueConnectionId.IsBound()) + if (!OnInsertOptionEveryPrimitiveStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionEveryPrimitiveStruct")); } return false; } - OnInsertCallerUniqueConnectionId.Broadcast(Context, Args->Data); + OnInsertOptionEveryPrimitiveStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertCallerUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerUniqueConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOptionEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertOptionEveryPrimitiveStructArgs& Args) { - if (!OnInsertCallerUniqueConnectionId.IsBound()) + if (!OnInsertOptionEveryPrimitiveStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionEveryPrimitiveStruct")); } return false; } - OnInsertCallerUniqueConnectionId.Broadcast(Context, Args.Data); + OnInsertOptionEveryPrimitiveStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertCallerUniqueIdentity(const int32 Data) +void URemoteReducers::InsertOptionI32(const FTestClientOptionalInt32 N) { if (!Conn) { @@ -6863,45 +10082,45 @@ void URemoteReducers::InsertCallerUniqueIdentity(const int32 Data) return; } - FInsertCallerUniqueIdentityArgs ReducerArgs(Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_unique_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerUniqueIdentity(ReducerArgs)); } + FInsertOptionI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerUniqueIdentity(const FReducerEventContext& Context, const UInsertCallerUniqueIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOptionI32(const FReducerEventContext& Context, const UInsertOptionI32Reducer* Args) { - if (!OnInsertCallerUniqueIdentity.IsBound()) + if (!OnInsertOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionI32")); } return false; } - OnInsertCallerUniqueIdentity.Broadcast(Context, Args->Data); + OnInsertOptionI32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallerUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerUniqueIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOptionI32WithArgs(const FReducerEventContext& Context, const FInsertOptionI32Args& Args) { - if (!OnInsertCallerUniqueIdentity.IsBound()) + if (!OnInsertOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionI32")); } return false; } - OnInsertCallerUniqueIdentity.Broadcast(Context, Args.Data); + OnInsertOptionI32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallerVecConnectionId() +void URemoteReducers::InsertOptionIdentity(const FTestClientOptionalIdentity& I) { if (!Conn) { @@ -6909,45 +10128,45 @@ void URemoteReducers::InsertCallerVecConnectionId() return; } - FInsertCallerVecConnectionIdArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_vec_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerVecConnectionId(ReducerArgs)); } + FInsertOptionIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerVecConnectionId(const FReducerEventContext& Context, const UInsertCallerVecConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOptionIdentity(const FReducerEventContext& Context, const UInsertOptionIdentityReducer* Args) { - if (!OnInsertCallerVecConnectionId.IsBound()) + if (!OnInsertOptionIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionIdentity")); } return false; } - OnInsertCallerVecConnectionId.Broadcast(Context); + OnInsertOptionIdentity.Broadcast(Context, Args->I); return true; } -bool URemoteReducers::InvokeInsertCallerVecConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerVecConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOptionIdentityWithArgs(const FReducerEventContext& Context, const FInsertOptionIdentityArgs& Args) { - if (!OnInsertCallerVecConnectionId.IsBound()) + if (!OnInsertOptionIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionIdentity")); } return false; } - OnInsertCallerVecConnectionId.Broadcast(Context); + OnInsertOptionIdentity.Broadcast(Context, Args.I); return true; } -void URemoteReducers::InsertCallerVecIdentity() +void URemoteReducers::InsertOptionSimpleEnum(const FTestClientOptionalSimpleEnum& E) { if (!Conn) { @@ -6955,45 +10174,45 @@ void URemoteReducers::InsertCallerVecIdentity() return; } - FInsertCallerVecIdentityArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_vec_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerVecIdentity(ReducerArgs)); } + FInsertOptionSimpleEnumArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerVecIdentity(const FReducerEventContext& Context, const UInsertCallerVecIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOptionSimpleEnum(const FReducerEventContext& Context, const UInsertOptionSimpleEnumReducer* Args) { - if (!OnInsertCallerVecIdentity.IsBound()) + if (!OnInsertOptionSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionSimpleEnum")); } return false; } - OnInsertCallerVecIdentity.Broadcast(Context); + OnInsertOptionSimpleEnum.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeInsertCallerVecIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerVecIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOptionSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertOptionSimpleEnumArgs& Args) { - if (!OnInsertCallerVecIdentity.IsBound()) + if (!OnInsertOptionSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionSimpleEnum")); } return false; } - OnInsertCallerVecIdentity.Broadcast(Context); + OnInsertOptionSimpleEnum.Broadcast(Context, Args.E); return true; } -void URemoteReducers::InsertIntoBtreeU32(const TArray& Rows) +void URemoteReducers::InsertOptionString(const FTestClientOptionalString& S) { if (!Conn) { @@ -7001,45 +10220,45 @@ void URemoteReducers::InsertIntoBtreeU32(const TArray& Rows) return; } - FInsertIntoBtreeU32Args ReducerArgs(Rows); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_btree_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoBtreeU32(ReducerArgs)); } + FInsertOptionStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertIntoBtreeU32(const FReducerEventContext& Context, const UInsertIntoBtreeU32Reducer* Args) +bool URemoteReducers::InvokeInsertOptionString(const FReducerEventContext& Context, const UInsertOptionStringReducer* Args) { - if (!OnInsertIntoBtreeU32.IsBound()) + if (!OnInsertOptionString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionString")); } return false; } - OnInsertIntoBtreeU32.Broadcast(Context, Args->Rows); + OnInsertOptionString.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertIntoBtreeU32WithArgs(const FReducerEventContext& Context, const FInsertIntoBtreeU32Args& Args) +bool URemoteReducers::InvokeInsertOptionStringWithArgs(const FReducerEventContext& Context, const FInsertOptionStringArgs& Args) { - if (!OnInsertIntoBtreeU32.IsBound()) + if (!OnInsertOptionString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionString")); } return false; } - OnInsertIntoBtreeU32.Broadcast(Context, Args.Rows); + OnInsertOptionString.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertIntoIndexedSimpleEnum(const ESimpleEnumType& N) +void URemoteReducers::InsertOptionUuid(const FTestClientOptionalUuid& U) { if (!Conn) { @@ -7047,45 +10266,45 @@ void URemoteReducers::InsertIntoIndexedSimpleEnum(const ESimpleEnumType& N) return; } - FInsertIntoIndexedSimpleEnumArgs ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_indexed_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoIndexedSimpleEnum(ReducerArgs)); } + FInsertOptionUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertIntoIndexedSimpleEnum(const FReducerEventContext& Context, const UInsertIntoIndexedSimpleEnumReducer* Args) +bool URemoteReducers::InvokeInsertOptionUuid(const FReducerEventContext& Context, const UInsertOptionUuidReducer* Args) { - if (!OnInsertIntoIndexedSimpleEnum.IsBound()) + if (!OnInsertOptionUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoIndexedSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionUuid")); } return false; } - OnInsertIntoIndexedSimpleEnum.Broadcast(Context, Args->N); + OnInsertOptionUuid.Broadcast(Context, Args->U); return true; } -bool URemoteReducers::InvokeInsertIntoIndexedSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertIntoIndexedSimpleEnumArgs& Args) +bool URemoteReducers::InvokeInsertOptionUuidWithArgs(const FReducerEventContext& Context, const FInsertOptionUuidArgs& Args) { - if (!OnInsertIntoIndexedSimpleEnum.IsBound()) + if (!OnInsertOptionUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoIndexedSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionUuid")); } return false; } - OnInsertIntoIndexedSimpleEnum.Broadcast(Context, Args.N); + OnInsertOptionUuid.Broadcast(Context, Args.U); return true; } -void URemoteReducers::InsertIntoPkBtreeU32(const TArray& PkU32, const TArray& BtU32) +void URemoteReducers::InsertOptionVecOptionI32(const FTestClientOptionalVecOptionalInt32& V) { if (!Conn) { @@ -7093,45 +10312,45 @@ void URemoteReducers::InsertIntoPkBtreeU32(const TArray& PkU32, cons return; } - FInsertIntoPkBtreeU32Args ReducerArgs(PkU32, BtU32); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_pk_btree_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoPkBtreeU32(ReducerArgs)); } + FInsertOptionVecOptionI32Args ReducerArgs(V); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_vec_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionVecOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertIntoPkBtreeU32(const FReducerEventContext& Context, const UInsertIntoPkBtreeU32Reducer* Args) +bool URemoteReducers::InvokeInsertOptionVecOptionI32(const FReducerEventContext& Context, const UInsertOptionVecOptionI32Reducer* Args) { - if (!OnInsertIntoPkBtreeU32.IsBound()) + if (!OnInsertOptionVecOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoPkBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionVecOptionI32")); } return false; } - OnInsertIntoPkBtreeU32.Broadcast(Context, Args->PkU32, Args->BtU32); + OnInsertOptionVecOptionI32.Broadcast(Context, Args->V); return true; } -bool URemoteReducers::InvokeInsertIntoPkBtreeU32WithArgs(const FReducerEventContext& Context, const FInsertIntoPkBtreeU32Args& Args) +bool URemoteReducers::InvokeInsertOptionVecOptionI32WithArgs(const FReducerEventContext& Context, const FInsertOptionVecOptionI32Args& Args) { - if (!OnInsertIntoPkBtreeU32.IsBound()) + if (!OnInsertOptionVecOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoPkBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionVecOptionI32")); } return false; } - OnInsertIntoPkBtreeU32.Broadcast(Context, Args.PkU32, Args.BtU32); + OnInsertOptionVecOptionI32.Broadcast(Context, Args.V); return true; } -void URemoteReducers::InsertLargeTable(const uint8 A, const uint16 B, const uint32 C, const uint64 D, const FSpacetimeDBUInt128& E, const FSpacetimeDBUInt256& F, const int8 G, const int16 H, const int32 I, const int64 J, const FSpacetimeDBInt128& K, const FSpacetimeDBInt256& L, const bool M, const float N, const double O, const FString& P, const ESimpleEnumType& Q, const FEnumWithPayloadType& R, const FUnitStructType& S, const FByteStructType& T, const FEveryPrimitiveStructType& U, const FEveryVecStructType& V) +void URemoteReducers::InsertPkBool(const bool B, const int32 Data) { if (!Conn) { @@ -7139,68 +10358,45 @@ void URemoteReducers::InsertLargeTable(const uint8 A, const uint16 B, const uint return; } - FInsertLargeTableArgs ReducerArgs(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_large_table"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertLargeTable(ReducerArgs)); } + FInsertPkBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertLargeTable(const FReducerEventContext& Context, const UInsertLargeTableReducer* Args) +bool URemoteReducers::InvokeInsertPkBool(const FReducerEventContext& Context, const UInsertPkBoolReducer* Args) { - if (!OnInsertLargeTable.IsBound()) + if (!OnInsertPkBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertLargeTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkBool")); } return false; } - FInsertLargeTableArgs ArgsStruct; - ArgsStruct.A = Args->A; - ArgsStruct.B = Args->B; - ArgsStruct.C = Args->C; - ArgsStruct.D = Args->D; - ArgsStruct.E = Args->E; - ArgsStruct.F = Args->F; - ArgsStruct.G = Args->G; - ArgsStruct.H = Args->H; - ArgsStruct.I = Args->I; - ArgsStruct.J = Args->J; - ArgsStruct.K = Args->K; - ArgsStruct.L = Args->L; - ArgsStruct.M = Args->M; - ArgsStruct.N = Args->N; - ArgsStruct.O = Args->O; - ArgsStruct.P = Args->P; - ArgsStruct.Q = Args->Q; - ArgsStruct.R = Args->R; - ArgsStruct.S = Args->S; - ArgsStruct.T = Args->T; - ArgsStruct.U = Args->U; - ArgsStruct.V = Args->V; - OnInsertLargeTable.Broadcast(Context, ArgsStruct); + OnInsertPkBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeInsertLargeTableWithArgs(const FReducerEventContext& Context, const FInsertLargeTableArgs& Args) +bool URemoteReducers::InvokeInsertPkBoolWithArgs(const FReducerEventContext& Context, const FInsertPkBoolArgs& Args) { - if (!OnInsertLargeTable.IsBound()) + if (!OnInsertPkBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertLargeTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkBool")); } return false; } - OnInsertLargeTable.Broadcast(Context, Args); + OnInsertPkBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::InsertOneBool(const bool B) +void URemoteReducers::InsertPkConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) { if (!Conn) { @@ -7208,45 +10404,45 @@ void URemoteReducers::InsertOneBool(const bool B) return; } - FInsertOneBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneBool(ReducerArgs)); } + FInsertPkConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneBool(const FReducerEventContext& Context, const UInsertOneBoolReducer* Args) +bool URemoteReducers::InvokeInsertPkConnectionId(const FReducerEventContext& Context, const UInsertPkConnectionIdReducer* Args) { - if (!OnInsertOneBool.IsBound()) + if (!OnInsertPkConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkConnectionId")); } return false; } - OnInsertOneBool.Broadcast(Context, Args->B); + OnInsertPkConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneBoolWithArgs(const FReducerEventContext& Context, const FInsertOneBoolArgs& Args) +bool URemoteReducers::InvokeInsertPkConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertPkConnectionIdArgs& Args) { - if (!OnInsertOneBool.IsBound()) + if (!OnInsertPkConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkConnectionId")); } return false; } - OnInsertOneBool.Broadcast(Context, Args.B); + OnInsertPkConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertOneByteStruct(const FByteStructType& S) +void URemoteReducers::InsertPkI128(const FSpacetimeDBInt128& N, const int32 Data) { if (!Conn) { @@ -7254,45 +10450,45 @@ void URemoteReducers::InsertOneByteStruct(const FByteStructType& S) return; } - FInsertOneByteStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_byte_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneByteStruct(ReducerArgs)); } + FInsertPkI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneByteStruct(const FReducerEventContext& Context, const UInsertOneByteStructReducer* Args) +bool URemoteReducers::InvokeInsertPkI128(const FReducerEventContext& Context, const UInsertPkI128Reducer* Args) { - if (!OnInsertOneByteStruct.IsBound()) + if (!OnInsertPkI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI128")); } return false; } - OnInsertOneByteStruct.Broadcast(Context, Args->S); + OnInsertPkI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneByteStructWithArgs(const FReducerEventContext& Context, const FInsertOneByteStructArgs& Args) +bool URemoteReducers::InvokeInsertPkI128WithArgs(const FReducerEventContext& Context, const FInsertPkI128Args& Args) { - if (!OnInsertOneByteStruct.IsBound()) + if (!OnInsertPkI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI128")); } return false; } - OnInsertOneByteStruct.Broadcast(Context, Args.S); + OnInsertPkI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneConnectionId(const FSpacetimeDBConnectionId& A) +void URemoteReducers::InsertPkI16(const int16 N, const int32 Data) { if (!Conn) { @@ -7300,45 +10496,45 @@ void URemoteReducers::InsertOneConnectionId(const FSpacetimeDBConnectionId& A) return; } - FInsertOneConnectionIdArgs ReducerArgs(A); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneConnectionId(ReducerArgs)); } + FInsertPkI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneConnectionId(const FReducerEventContext& Context, const UInsertOneConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertPkI16(const FReducerEventContext& Context, const UInsertPkI16Reducer* Args) { - if (!OnInsertOneConnectionId.IsBound()) + if (!OnInsertPkI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI16")); } return false; } - OnInsertOneConnectionId.Broadcast(Context, Args->A); + OnInsertPkI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertOneConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertPkI16WithArgs(const FReducerEventContext& Context, const FInsertPkI16Args& Args) { - if (!OnInsertOneConnectionId.IsBound()) + if (!OnInsertPkI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI16")); } return false; } - OnInsertOneConnectionId.Broadcast(Context, Args.A); + OnInsertPkI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneEnumWithPayload(const FEnumWithPayloadType& E) +void URemoteReducers::InsertPkI256(const FSpacetimeDBInt256& N, const int32 Data) { if (!Conn) { @@ -7346,45 +10542,45 @@ void URemoteReducers::InsertOneEnumWithPayload(const FEnumWithPayloadType& E) return; } - FInsertOneEnumWithPayloadArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_enum_with_payload"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEnumWithPayload(ReducerArgs)); } + FInsertPkI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneEnumWithPayload(const FReducerEventContext& Context, const UInsertOneEnumWithPayloadReducer* Args) +bool URemoteReducers::InvokeInsertPkI256(const FReducerEventContext& Context, const UInsertPkI256Reducer* Args) { - if (!OnInsertOneEnumWithPayload.IsBound()) + if (!OnInsertPkI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI256")); } return false; } - OnInsertOneEnumWithPayload.Broadcast(Context, Args->E); + OnInsertPkI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FInsertOneEnumWithPayloadArgs& Args) +bool URemoteReducers::InvokeInsertPkI256WithArgs(const FReducerEventContext& Context, const FInsertPkI256Args& Args) { - if (!OnInsertOneEnumWithPayload.IsBound()) + if (!OnInsertPkI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI256")); } return false; } - OnInsertOneEnumWithPayload.Broadcast(Context, Args.E); + OnInsertPkI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneEveryPrimitiveStruct(const FEveryPrimitiveStructType& S) +void URemoteReducers::InsertPkI32(const int32 N, const int32 Data) { if (!Conn) { @@ -7392,45 +10588,45 @@ void URemoteReducers::InsertOneEveryPrimitiveStruct(const FEveryPrimitiveStructT return; } - FInsertOneEveryPrimitiveStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_every_primitive_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEveryPrimitiveStruct(ReducerArgs)); } + FInsertPkI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertOneEveryPrimitiveStructReducer* Args) +bool URemoteReducers::InvokeInsertPkI32(const FReducerEventContext& Context, const UInsertPkI32Reducer* Args) { - if (!OnInsertOneEveryPrimitiveStruct.IsBound()) + if (!OnInsertPkI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI32")); } return false; } - OnInsertOneEveryPrimitiveStruct.Broadcast(Context, Args->S); + OnInsertPkI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertOneEveryPrimitiveStructArgs& Args) +bool URemoteReducers::InvokeInsertPkI32WithArgs(const FReducerEventContext& Context, const FInsertPkI32Args& Args) { - if (!OnInsertOneEveryPrimitiveStruct.IsBound()) + if (!OnInsertPkI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI32")); } return false; } - OnInsertOneEveryPrimitiveStruct.Broadcast(Context, Args.S); + OnInsertPkI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneEveryVecStruct(const FEveryVecStructType& S) +void URemoteReducers::InsertPkI64(const int64 N, const int32 Data) { if (!Conn) { @@ -7438,45 +10634,45 @@ void URemoteReducers::InsertOneEveryVecStruct(const FEveryVecStructType& S) return; } - FInsertOneEveryVecStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_every_vec_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEveryVecStruct(ReducerArgs)); } + FInsertPkI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneEveryVecStruct(const FReducerEventContext& Context, const UInsertOneEveryVecStructReducer* Args) +bool URemoteReducers::InvokeInsertPkI64(const FReducerEventContext& Context, const UInsertPkI64Reducer* Args) { - if (!OnInsertOneEveryVecStruct.IsBound()) + if (!OnInsertPkI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI64")); } return false; } - OnInsertOneEveryVecStruct.Broadcast(Context, Args->S); + OnInsertPkI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneEveryVecStructWithArgs(const FReducerEventContext& Context, const FInsertOneEveryVecStructArgs& Args) +bool URemoteReducers::InvokeInsertPkI64WithArgs(const FReducerEventContext& Context, const FInsertPkI64Args& Args) { - if (!OnInsertOneEveryVecStruct.IsBound()) + if (!OnInsertPkI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI64")); } return false; } - OnInsertOneEveryVecStruct.Broadcast(Context, Args.S); + OnInsertPkI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneF32(const float F) +void URemoteReducers::InsertPkI8(const int8 N, const int32 Data) { if (!Conn) { @@ -7484,45 +10680,45 @@ void URemoteReducers::InsertOneF32(const float F) return; } - FInsertOneF32Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_f_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneF32(ReducerArgs)); } + FInsertPkI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneF32(const FReducerEventContext& Context, const UInsertOneF32Reducer* Args) +bool URemoteReducers::InvokeInsertPkI8(const FReducerEventContext& Context, const UInsertPkI8Reducer* Args) { - if (!OnInsertOneF32.IsBound()) + if (!OnInsertPkI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI8")); } return false; } - OnInsertOneF32.Broadcast(Context, Args->F); + OnInsertPkI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneF32WithArgs(const FReducerEventContext& Context, const FInsertOneF32Args& Args) +bool URemoteReducers::InvokeInsertPkI8WithArgs(const FReducerEventContext& Context, const FInsertPkI8Args& Args) { - if (!OnInsertOneF32.IsBound()) + if (!OnInsertPkI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI8")); } return false; } - OnInsertOneF32.Broadcast(Context, Args.F); + OnInsertPkI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneF64(const double F) +void URemoteReducers::InsertPkIdentity(const FSpacetimeDBIdentity& I, const int32 Data) { if (!Conn) { @@ -7530,45 +10726,45 @@ void URemoteReducers::InsertOneF64(const double F) return; } - FInsertOneF64Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_f_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneF64(ReducerArgs)); } + FInsertPkIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneF64(const FReducerEventContext& Context, const UInsertOneF64Reducer* Args) +bool URemoteReducers::InvokeInsertPkIdentity(const FReducerEventContext& Context, const UInsertPkIdentityReducer* Args) { - if (!OnInsertOneF64.IsBound()) + if (!OnInsertPkIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkIdentity")); } return false; } - OnInsertOneF64.Broadcast(Context, Args->F); + OnInsertPkIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneF64WithArgs(const FReducerEventContext& Context, const FInsertOneF64Args& Args) +bool URemoteReducers::InvokeInsertPkIdentityWithArgs(const FReducerEventContext& Context, const FInsertPkIdentityArgs& Args) { - if (!OnInsertOneF64.IsBound()) + if (!OnInsertPkIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkIdentity")); } return false; } - OnInsertOneF64.Broadcast(Context, Args.F); + OnInsertPkIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::InsertOneI128(const FSpacetimeDBInt128& N) +void URemoteReducers::InsertPkSimpleEnum(const ESimpleEnumType& A, const int32 Data) { if (!Conn) { @@ -7576,45 +10772,45 @@ void URemoteReducers::InsertOneI128(const FSpacetimeDBInt128& N) return; } - FInsertOneI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI128(ReducerArgs)); } + FInsertPkSimpleEnumArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI128(const FReducerEventContext& Context, const UInsertOneI128Reducer* Args) +bool URemoteReducers::InvokeInsertPkSimpleEnum(const FReducerEventContext& Context, const UInsertPkSimpleEnumReducer* Args) { - if (!OnInsertOneI128.IsBound()) + if (!OnInsertPkSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkSimpleEnum")); } return false; } - OnInsertOneI128.Broadcast(Context, Args->N); + OnInsertPkSimpleEnum.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI128WithArgs(const FReducerEventContext& Context, const FInsertOneI128Args& Args) +bool URemoteReducers::InvokeInsertPkSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertPkSimpleEnumArgs& Args) { - if (!OnInsertOneI128.IsBound()) + if (!OnInsertPkSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkSimpleEnum")); } return false; } - OnInsertOneI128.Broadcast(Context, Args.N); + OnInsertPkSimpleEnum.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertOneI16(const int16 N) +void URemoteReducers::InsertPkString(const FString& S, const int32 Data) { if (!Conn) { @@ -7622,45 +10818,45 @@ void URemoteReducers::InsertOneI16(const int16 N) return; } - FInsertOneI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI16(ReducerArgs)); } + FInsertPkStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI16(const FReducerEventContext& Context, const UInsertOneI16Reducer* Args) +bool URemoteReducers::InvokeInsertPkString(const FReducerEventContext& Context, const UInsertPkStringReducer* Args) { - if (!OnInsertOneI16.IsBound()) + if (!OnInsertPkString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkString")); } return false; } - OnInsertOneI16.Broadcast(Context, Args->N); + OnInsertPkString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI16WithArgs(const FReducerEventContext& Context, const FInsertOneI16Args& Args) +bool URemoteReducers::InvokeInsertPkStringWithArgs(const FReducerEventContext& Context, const FInsertPkStringArgs& Args) { - if (!OnInsertOneI16.IsBound()) + if (!OnInsertPkString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkString")); } return false; } - OnInsertOneI16.Broadcast(Context, Args.N); + OnInsertPkString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::InsertOneI256(const FSpacetimeDBInt256& N) +void URemoteReducers::InsertPkU128(const FSpacetimeDBUInt128& N, const int32 Data) { if (!Conn) { @@ -7668,45 +10864,45 @@ void URemoteReducers::InsertOneI256(const FSpacetimeDBInt256& N) return; } - FInsertOneI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI256(ReducerArgs)); } + FInsertPkU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI256(const FReducerEventContext& Context, const UInsertOneI256Reducer* Args) +bool URemoteReducers::InvokeInsertPkU128(const FReducerEventContext& Context, const UInsertPkU128Reducer* Args) { - if (!OnInsertOneI256.IsBound()) + if (!OnInsertPkU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU128")); } return false; } - OnInsertOneI256.Broadcast(Context, Args->N); + OnInsertPkU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI256WithArgs(const FReducerEventContext& Context, const FInsertOneI256Args& Args) +bool URemoteReducers::InvokeInsertPkU128WithArgs(const FReducerEventContext& Context, const FInsertPkU128Args& Args) { - if (!OnInsertOneI256.IsBound()) + if (!OnInsertPkU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU128")); } return false; } - OnInsertOneI256.Broadcast(Context, Args.N); + OnInsertPkU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneI32(const int32 N) +void URemoteReducers::InsertPkU16(const uint16 N, const int32 Data) { if (!Conn) { @@ -7714,45 +10910,45 @@ void URemoteReducers::InsertOneI32(const int32 N) return; } - FInsertOneI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI32(ReducerArgs)); } + FInsertPkU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI32(const FReducerEventContext& Context, const UInsertOneI32Reducer* Args) +bool URemoteReducers::InvokeInsertPkU16(const FReducerEventContext& Context, const UInsertPkU16Reducer* Args) { - if (!OnInsertOneI32.IsBound()) + if (!OnInsertPkU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU16")); } return false; } - OnInsertOneI32.Broadcast(Context, Args->N); + OnInsertPkU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI32WithArgs(const FReducerEventContext& Context, const FInsertOneI32Args& Args) +bool URemoteReducers::InvokeInsertPkU16WithArgs(const FReducerEventContext& Context, const FInsertPkU16Args& Args) { - if (!OnInsertOneI32.IsBound()) + if (!OnInsertPkU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU16")); } return false; } - OnInsertOneI32.Broadcast(Context, Args.N); + OnInsertPkU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneI64(const int64 N) +void URemoteReducers::InsertPkU256(const FSpacetimeDBUInt256& N, const int32 Data) { if (!Conn) { @@ -7760,45 +10956,45 @@ void URemoteReducers::InsertOneI64(const int64 N) return; } - FInsertOneI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI64(ReducerArgs)); } + FInsertPkU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI64(const FReducerEventContext& Context, const UInsertOneI64Reducer* Args) +bool URemoteReducers::InvokeInsertPkU256(const FReducerEventContext& Context, const UInsertPkU256Reducer* Args) { - if (!OnInsertOneI64.IsBound()) + if (!OnInsertPkU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU256")); } return false; } - OnInsertOneI64.Broadcast(Context, Args->N); + OnInsertPkU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI64WithArgs(const FReducerEventContext& Context, const FInsertOneI64Args& Args) +bool URemoteReducers::InvokeInsertPkU256WithArgs(const FReducerEventContext& Context, const FInsertPkU256Args& Args) { - if (!OnInsertOneI64.IsBound()) + if (!OnInsertPkU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU256")); } return false; } - OnInsertOneI64.Broadcast(Context, Args.N); + OnInsertPkU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneI8(const int8 N) +void URemoteReducers::InsertPkU32(const uint32 N, const int32 Data) { if (!Conn) { @@ -7806,45 +11002,45 @@ void URemoteReducers::InsertOneI8(const int8 N) return; } - FInsertOneI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI8(ReducerArgs)); } + FInsertPkU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI8(const FReducerEventContext& Context, const UInsertOneI8Reducer* Args) +bool URemoteReducers::InvokeInsertPkU32(const FReducerEventContext& Context, const UInsertPkU32Reducer* Args) { - if (!OnInsertOneI8.IsBound()) + if (!OnInsertPkU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32")); } return false; } - OnInsertOneI8.Broadcast(Context, Args->N); + OnInsertPkU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI8WithArgs(const FReducerEventContext& Context, const FInsertOneI8Args& Args) +bool URemoteReducers::InvokeInsertPkU32WithArgs(const FReducerEventContext& Context, const FInsertPkU32Args& Args) { - if (!OnInsertOneI8.IsBound()) + if (!OnInsertPkU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32")); } return false; } - OnInsertOneI8.Broadcast(Context, Args.N); + OnInsertPkU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneIdentity(const FSpacetimeDBIdentity& I) +void URemoteReducers::InsertPkU32Two(const uint32 N, const int32 Data) { if (!Conn) { @@ -7852,45 +11048,45 @@ void URemoteReducers::InsertOneIdentity(const FSpacetimeDBIdentity& I) return; } - FInsertOneIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneIdentity(ReducerArgs)); } + FInsertPkU32TwoArgs ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_32_two"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU32Two(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneIdentity(const FReducerEventContext& Context, const UInsertOneIdentityReducer* Args) +bool URemoteReducers::InvokeInsertPkU32Two(const FReducerEventContext& Context, const UInsertPkU32TwoReducer* Args) { - if (!OnInsertOneIdentity.IsBound()) + if (!OnInsertPkU32Two.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32Two")); } return false; } - OnInsertOneIdentity.Broadcast(Context, Args->I); + OnInsertPkU32Two.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneIdentityWithArgs(const FReducerEventContext& Context, const FInsertOneIdentityArgs& Args) +bool URemoteReducers::InvokeInsertPkU32TwoWithArgs(const FReducerEventContext& Context, const FInsertPkU32TwoArgs& Args) { - if (!OnInsertOneIdentity.IsBound()) + if (!OnInsertPkU32Two.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32Two")); } return false; } - OnInsertOneIdentity.Broadcast(Context, Args.I); + OnInsertPkU32Two.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneSimpleEnum(const ESimpleEnumType& E) +void URemoteReducers::InsertPkU64(const uint64 N, const int32 Data) { if (!Conn) { @@ -7898,45 +11094,45 @@ void URemoteReducers::InsertOneSimpleEnum(const ESimpleEnumType& E) return; } - FInsertOneSimpleEnumArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneSimpleEnum(ReducerArgs)); } + FInsertPkU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneSimpleEnum(const FReducerEventContext& Context, const UInsertOneSimpleEnumReducer* Args) +bool URemoteReducers::InvokeInsertPkU64(const FReducerEventContext& Context, const UInsertPkU64Reducer* Args) { - if (!OnInsertOneSimpleEnum.IsBound()) + if (!OnInsertPkU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU64")); } return false; } - OnInsertOneSimpleEnum.Broadcast(Context, Args->E); + OnInsertPkU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertOneSimpleEnumArgs& Args) +bool URemoteReducers::InvokeInsertPkU64WithArgs(const FReducerEventContext& Context, const FInsertPkU64Args& Args) { - if (!OnInsertOneSimpleEnum.IsBound()) + if (!OnInsertPkU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU64")); } return false; } - OnInsertOneSimpleEnum.Broadcast(Context, Args.E); + OnInsertPkU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneString(const FString& S) +void URemoteReducers::InsertPkU8(const uint8 N, const int32 Data) { if (!Conn) { @@ -7944,45 +11140,45 @@ void URemoteReducers::InsertOneString(const FString& S) return; } - FInsertOneStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneString(ReducerArgs)); } + FInsertPkU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneString(const FReducerEventContext& Context, const UInsertOneStringReducer* Args) +bool URemoteReducers::InvokeInsertPkU8(const FReducerEventContext& Context, const UInsertPkU8Reducer* Args) { - if (!OnInsertOneString.IsBound()) + if (!OnInsertPkU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU8")); } return false; } - OnInsertOneString.Broadcast(Context, Args->S); + OnInsertPkU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneStringWithArgs(const FReducerEventContext& Context, const FInsertOneStringArgs& Args) +bool URemoteReducers::InvokeInsertPkU8WithArgs(const FReducerEventContext& Context, const FInsertPkU8Args& Args) { - if (!OnInsertOneString.IsBound()) + if (!OnInsertPkU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU8")); } return false; } - OnInsertOneString.Broadcast(Context, Args.S); + OnInsertPkU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneTimestamp(const FSpacetimeDBTimestamp& T) +void URemoteReducers::InsertPkUuid(const FSpacetimeDBUuid& U, const int32 Data) { if (!Conn) { @@ -7990,45 +11186,45 @@ void URemoteReducers::InsertOneTimestamp(const FSpacetimeDBTimestamp& T) return; } - FInsertOneTimestampArgs ReducerArgs(T); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_timestamp"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneTimestamp(ReducerArgs)); } + FInsertPkUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneTimestamp(const FReducerEventContext& Context, const UInsertOneTimestampReducer* Args) +bool URemoteReducers::InvokeInsertPkUuid(const FReducerEventContext& Context, const UInsertPkUuidReducer* Args) { - if (!OnInsertOneTimestamp.IsBound()) + if (!OnInsertPkUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkUuid")); } return false; } - OnInsertOneTimestamp.Broadcast(Context, Args->T); + OnInsertPkUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneTimestampWithArgs(const FReducerEventContext& Context, const FInsertOneTimestampArgs& Args) +bool URemoteReducers::InvokeInsertPkUuidWithArgs(const FReducerEventContext& Context, const FInsertPkUuidArgs& Args) { - if (!OnInsertOneTimestamp.IsBound()) + if (!OnInsertPkUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkUuid")); } return false; } - OnInsertOneTimestamp.Broadcast(Context, Args.T); + OnInsertPkUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::InsertOneU128(const FSpacetimeDBUInt128& N) +void URemoteReducers::InsertPrimitivesAsStrings(const FEveryPrimitiveStructType& S) { if (!Conn) { @@ -8036,45 +11232,45 @@ void URemoteReducers::InsertOneU128(const FSpacetimeDBUInt128& N) return; } - FInsertOneU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU128(ReducerArgs)); } + FInsertPrimitivesAsStringsArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_primitives_as_strings"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPrimitivesAsStrings(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU128(const FReducerEventContext& Context, const UInsertOneU128Reducer* Args) +bool URemoteReducers::InvokeInsertPrimitivesAsStrings(const FReducerEventContext& Context, const UInsertPrimitivesAsStringsReducer* Args) { - if (!OnInsertOneU128.IsBound()) + if (!OnInsertPrimitivesAsStrings.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPrimitivesAsStrings")); } return false; } - OnInsertOneU128.Broadcast(Context, Args->N); + OnInsertPrimitivesAsStrings.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertOneU128WithArgs(const FReducerEventContext& Context, const FInsertOneU128Args& Args) +bool URemoteReducers::InvokeInsertPrimitivesAsStringsWithArgs(const FReducerEventContext& Context, const FInsertPrimitivesAsStringsArgs& Args) { - if (!OnInsertOneU128.IsBound()) + if (!OnInsertPrimitivesAsStrings.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPrimitivesAsStrings")); } return false; } - OnInsertOneU128.Broadcast(Context, Args.N); + OnInsertPrimitivesAsStrings.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertOneU16(const uint16 N) +void URemoteReducers::InsertResultEveryPrimitiveStructString(const FTestClientResultEveryPrimitiveStructString& R) { if (!Conn) { @@ -8082,45 +11278,45 @@ void URemoteReducers::InsertOneU16(const uint16 N) return; } - FInsertOneU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU16(ReducerArgs)); } + FInsertResultEveryPrimitiveStructStringArgs ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_every_primitive_struct_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultEveryPrimitiveStructString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU16(const FReducerEventContext& Context, const UInsertOneU16Reducer* Args) +bool URemoteReducers::InvokeInsertResultEveryPrimitiveStructString(const FReducerEventContext& Context, const UInsertResultEveryPrimitiveStructStringReducer* Args) { - if (!OnInsertOneU16.IsBound()) + if (!OnInsertResultEveryPrimitiveStructString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultEveryPrimitiveStructString")); } return false; } - OnInsertOneU16.Broadcast(Context, Args->N); + OnInsertResultEveryPrimitiveStructString.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU16WithArgs(const FReducerEventContext& Context, const FInsertOneU16Args& Args) +bool URemoteReducers::InvokeInsertResultEveryPrimitiveStructStringWithArgs(const FReducerEventContext& Context, const FInsertResultEveryPrimitiveStructStringArgs& Args) { - if (!OnInsertOneU16.IsBound()) + if (!OnInsertResultEveryPrimitiveStructString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultEveryPrimitiveStructString")); } return false; } - OnInsertOneU16.Broadcast(Context, Args.N); + OnInsertResultEveryPrimitiveStructString.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneU256(const FSpacetimeDBUInt256& N) +void URemoteReducers::InsertResultI32String(const FTestClientResultInt32String& R) { if (!Conn) { @@ -8128,45 +11324,45 @@ void URemoteReducers::InsertOneU256(const FSpacetimeDBUInt256& N) return; } - FInsertOneU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU256(ReducerArgs)); } + FInsertResultI32StringArgs ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_i_32_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultI32String(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU256(const FReducerEventContext& Context, const UInsertOneU256Reducer* Args) +bool URemoteReducers::InvokeInsertResultI32String(const FReducerEventContext& Context, const UInsertResultI32StringReducer* Args) { - if (!OnInsertOneU256.IsBound()) + if (!OnInsertResultI32String.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultI32String")); } return false; } - OnInsertOneU256.Broadcast(Context, Args->N); + OnInsertResultI32String.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU256WithArgs(const FReducerEventContext& Context, const FInsertOneU256Args& Args) +bool URemoteReducers::InvokeInsertResultI32StringWithArgs(const FReducerEventContext& Context, const FInsertResultI32StringArgs& Args) { - if (!OnInsertOneU256.IsBound()) + if (!OnInsertResultI32String.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultI32String")); } return false; } - OnInsertOneU256.Broadcast(Context, Args.N); + OnInsertResultI32String.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneU32(const uint32 N) +void URemoteReducers::InsertResultIdentityString(const FTestClientResultIdentityString& R) { if (!Conn) { @@ -8174,45 +11370,45 @@ void URemoteReducers::InsertOneU32(const uint32 N) return; } - FInsertOneU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU32(ReducerArgs)); } + FInsertResultIdentityStringArgs ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_identity_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultIdentityString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU32(const FReducerEventContext& Context, const UInsertOneU32Reducer* Args) +bool URemoteReducers::InvokeInsertResultIdentityString(const FReducerEventContext& Context, const UInsertResultIdentityStringReducer* Args) { - if (!OnInsertOneU32.IsBound()) + if (!OnInsertResultIdentityString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultIdentityString")); } return false; } - OnInsertOneU32.Broadcast(Context, Args->N); + OnInsertResultIdentityString.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU32WithArgs(const FReducerEventContext& Context, const FInsertOneU32Args& Args) +bool URemoteReducers::InvokeInsertResultIdentityStringWithArgs(const FReducerEventContext& Context, const FInsertResultIdentityStringArgs& Args) { - if (!OnInsertOneU32.IsBound()) + if (!OnInsertResultIdentityString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultIdentityString")); } return false; } - OnInsertOneU32.Broadcast(Context, Args.N); + OnInsertResultIdentityString.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneU64(const uint64 N) +void URemoteReducers::InsertResultSimpleEnumI32(const FTestClientResultSimpleEnumInt32& R) { if (!Conn) { @@ -8220,45 +11416,45 @@ void URemoteReducers::InsertOneU64(const uint64 N) return; } - FInsertOneU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU64(ReducerArgs)); } + FInsertResultSimpleEnumI32Args ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_simple_enum_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultSimpleEnumI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU64(const FReducerEventContext& Context, const UInsertOneU64Reducer* Args) +bool URemoteReducers::InvokeInsertResultSimpleEnumI32(const FReducerEventContext& Context, const UInsertResultSimpleEnumI32Reducer* Args) { - if (!OnInsertOneU64.IsBound()) + if (!OnInsertResultSimpleEnumI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultSimpleEnumI32")); } return false; } - OnInsertOneU64.Broadcast(Context, Args->N); + OnInsertResultSimpleEnumI32.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU64WithArgs(const FReducerEventContext& Context, const FInsertOneU64Args& Args) +bool URemoteReducers::InvokeInsertResultSimpleEnumI32WithArgs(const FReducerEventContext& Context, const FInsertResultSimpleEnumI32Args& Args) { - if (!OnInsertOneU64.IsBound()) + if (!OnInsertResultSimpleEnumI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultSimpleEnumI32")); } return false; } - OnInsertOneU64.Broadcast(Context, Args.N); + OnInsertResultSimpleEnumI32.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneU8(const uint8 N) +void URemoteReducers::InsertResultStringI32(const FTestClientResultStringInt32& R) { if (!Conn) { @@ -8266,45 +11462,45 @@ void URemoteReducers::InsertOneU8(const uint8 N) return; } - FInsertOneU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU8(ReducerArgs)); } + FInsertResultStringI32Args ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_string_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultStringI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU8(const FReducerEventContext& Context, const UInsertOneU8Reducer* Args) +bool URemoteReducers::InvokeInsertResultStringI32(const FReducerEventContext& Context, const UInsertResultStringI32Reducer* Args) { - if (!OnInsertOneU8.IsBound()) + if (!OnInsertResultStringI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultStringI32")); } return false; } - OnInsertOneU8.Broadcast(Context, Args->N); + OnInsertResultStringI32.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU8WithArgs(const FReducerEventContext& Context, const FInsertOneU8Args& Args) +bool URemoteReducers::InvokeInsertResultStringI32WithArgs(const FReducerEventContext& Context, const FInsertResultStringI32Args& Args) { - if (!OnInsertOneU8.IsBound()) + if (!OnInsertResultStringI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultStringI32")); } return false; } - OnInsertOneU8.Broadcast(Context, Args.N); + OnInsertResultStringI32.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneUnitStruct(const FUnitStructType& S) +void URemoteReducers::InsertResultVecI32String(const FTestClientResultVecInt32String& R) { if (!Conn) { @@ -8312,45 +11508,45 @@ void URemoteReducers::InsertOneUnitStruct(const FUnitStructType& S) return; } - FInsertOneUnitStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_unit_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneUnitStruct(ReducerArgs)); } + FInsertResultVecI32StringArgs ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_vec_i_32_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultVecI32String(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneUnitStruct(const FReducerEventContext& Context, const UInsertOneUnitStructReducer* Args) +bool URemoteReducers::InvokeInsertResultVecI32String(const FReducerEventContext& Context, const UInsertResultVecI32StringReducer* Args) { - if (!OnInsertOneUnitStruct.IsBound()) + if (!OnInsertResultVecI32String.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultVecI32String")); } return false; } - OnInsertOneUnitStruct.Broadcast(Context, Args->S); + OnInsertResultVecI32String.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneUnitStructWithArgs(const FReducerEventContext& Context, const FInsertOneUnitStructArgs& Args) +bool URemoteReducers::InvokeInsertResultVecI32StringWithArgs(const FReducerEventContext& Context, const FInsertResultVecI32StringArgs& Args) { - if (!OnInsertOneUnitStruct.IsBound()) + if (!OnInsertResultVecI32String.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultVecI32String")); } return false; } - OnInsertOneUnitStruct.Broadcast(Context, Args.S); + OnInsertResultVecI32String.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneUuid(const FSpacetimeDBUuid& U) +void URemoteReducers::InsertTableHoldsTable(const FOneU8Type& A, const FVecU8Type& B) { if (!Conn) { @@ -8358,45 +11554,45 @@ void URemoteReducers::InsertOneUuid(const FSpacetimeDBUuid& U) return; } - FInsertOneUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneUuid(ReducerArgs)); } + FInsertTableHoldsTableArgs ReducerArgs(A, B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_table_holds_table"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertTableHoldsTable(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneUuid(const FReducerEventContext& Context, const UInsertOneUuidReducer* Args) +bool URemoteReducers::InvokeInsertTableHoldsTable(const FReducerEventContext& Context, const UInsertTableHoldsTableReducer* Args) { - if (!OnInsertOneUuid.IsBound()) + if (!OnInsertTableHoldsTable.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertTableHoldsTable")); } return false; } - OnInsertOneUuid.Broadcast(Context, Args->U); + OnInsertTableHoldsTable.Broadcast(Context, Args->A, Args->B); return true; } -bool URemoteReducers::InvokeInsertOneUuidWithArgs(const FReducerEventContext& Context, const FInsertOneUuidArgs& Args) +bool URemoteReducers::InvokeInsertTableHoldsTableWithArgs(const FReducerEventContext& Context, const FInsertTableHoldsTableArgs& Args) { - if (!OnInsertOneUuid.IsBound()) + if (!OnInsertTableHoldsTable.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertTableHoldsTable")); } return false; } - OnInsertOneUuid.Broadcast(Context, Args.U); + OnInsertTableHoldsTable.Broadcast(Context, Args.A, Args.B); return true; } -void URemoteReducers::InsertOptionEveryPrimitiveStruct(const FTestClientOptionalEveryPrimitiveStruct& S) +void URemoteReducers::InsertUniqueBool(const bool B, const int32 Data) { if (!Conn) { @@ -8404,45 +11600,45 @@ void URemoteReducers::InsertOptionEveryPrimitiveStruct(const FTestClientOptional return; } - FInsertOptionEveryPrimitiveStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_every_primitive_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionEveryPrimitiveStruct(ReducerArgs)); } + FInsertUniqueBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertOptionEveryPrimitiveStructReducer* Args) +bool URemoteReducers::InvokeInsertUniqueBool(const FReducerEventContext& Context, const UInsertUniqueBoolReducer* Args) { - if (!OnInsertOptionEveryPrimitiveStruct.IsBound()) + if (!OnInsertUniqueBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueBool")); } return false; } - OnInsertOptionEveryPrimitiveStruct.Broadcast(Context, Args->S); + OnInsertUniqueBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertOptionEveryPrimitiveStructArgs& Args) +bool URemoteReducers::InvokeInsertUniqueBoolWithArgs(const FReducerEventContext& Context, const FInsertUniqueBoolArgs& Args) { - if (!OnInsertOptionEveryPrimitiveStruct.IsBound()) + if (!OnInsertUniqueBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueBool")); } return false; } - OnInsertOptionEveryPrimitiveStruct.Broadcast(Context, Args.S); + OnInsertUniqueBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::InsertOptionI32(const FTestClientOptionalInt32 N) +void URemoteReducers::InsertUniqueConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) { if (!Conn) { @@ -8450,45 +11646,45 @@ void URemoteReducers::InsertOptionI32(const FTestClientOptionalInt32 N) return; } - FInsertOptionI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionI32(ReducerArgs)); } + FInsertUniqueConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionI32(const FReducerEventContext& Context, const UInsertOptionI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueConnectionId(const FReducerEventContext& Context, const UInsertUniqueConnectionIdReducer* Args) { - if (!OnInsertOptionI32.IsBound()) + if (!OnInsertUniqueConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueConnectionId")); } return false; } - OnInsertOptionI32.Broadcast(Context, Args->N); + OnInsertUniqueConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionI32WithArgs(const FReducerEventContext& Context, const FInsertOptionI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertUniqueConnectionIdArgs& Args) { - if (!OnInsertOptionI32.IsBound()) + if (!OnInsertUniqueConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueConnectionId")); } return false; } - OnInsertOptionI32.Broadcast(Context, Args.N); + OnInsertUniqueConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertOptionIdentity(const FTestClientOptionalIdentity& I) +void URemoteReducers::InsertUniqueI128(const FSpacetimeDBInt128& N, const int32 Data) { if (!Conn) { @@ -8496,45 +11692,45 @@ void URemoteReducers::InsertOptionIdentity(const FTestClientOptionalIdentity& I) return; } - FInsertOptionIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionIdentity(ReducerArgs)); } + FInsertUniqueI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionIdentity(const FReducerEventContext& Context, const UInsertOptionIdentityReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI128(const FReducerEventContext& Context, const UInsertUniqueI128Reducer* Args) { - if (!OnInsertOptionIdentity.IsBound()) + if (!OnInsertUniqueI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI128")); } return false; } - OnInsertOptionIdentity.Broadcast(Context, Args->I); + OnInsertUniqueI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionIdentityWithArgs(const FReducerEventContext& Context, const FInsertOptionIdentityArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI128WithArgs(const FReducerEventContext& Context, const FInsertUniqueI128Args& Args) { - if (!OnInsertOptionIdentity.IsBound()) + if (!OnInsertUniqueI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI128")); } return false; } - OnInsertOptionIdentity.Broadcast(Context, Args.I); + OnInsertUniqueI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOptionSimpleEnum(const FTestClientOptionalSimpleEnum& E) +void URemoteReducers::InsertUniqueI16(const int16 N, const int32 Data) { if (!Conn) { @@ -8542,45 +11738,45 @@ void URemoteReducers::InsertOptionSimpleEnum(const FTestClientOptionalSimpleEnum return; } - FInsertOptionSimpleEnumArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionSimpleEnum(ReducerArgs)); } + FInsertUniqueI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionSimpleEnum(const FReducerEventContext& Context, const UInsertOptionSimpleEnumReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI16(const FReducerEventContext& Context, const UInsertUniqueI16Reducer* Args) { - if (!OnInsertOptionSimpleEnum.IsBound()) + if (!OnInsertUniqueI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI16")); } return false; } - OnInsertOptionSimpleEnum.Broadcast(Context, Args->E); + OnInsertUniqueI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertOptionSimpleEnumArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI16WithArgs(const FReducerEventContext& Context, const FInsertUniqueI16Args& Args) { - if (!OnInsertOptionSimpleEnum.IsBound()) + if (!OnInsertUniqueI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI16")); } return false; } - OnInsertOptionSimpleEnum.Broadcast(Context, Args.E); + OnInsertUniqueI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOptionString(const FTestClientOptionalString& S) +void URemoteReducers::InsertUniqueI256(const FSpacetimeDBInt256& N, const int32 Data) { if (!Conn) { @@ -8588,45 +11784,45 @@ void URemoteReducers::InsertOptionString(const FTestClientOptionalString& S) return; } - FInsertOptionStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionString(ReducerArgs)); } + FInsertUniqueI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionString(const FReducerEventContext& Context, const UInsertOptionStringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI256(const FReducerEventContext& Context, const UInsertUniqueI256Reducer* Args) { - if (!OnInsertOptionString.IsBound()) + if (!OnInsertUniqueI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI256")); } return false; } - OnInsertOptionString.Broadcast(Context, Args->S); + OnInsertUniqueI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionStringWithArgs(const FReducerEventContext& Context, const FInsertOptionStringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI256WithArgs(const FReducerEventContext& Context, const FInsertUniqueI256Args& Args) { - if (!OnInsertOptionString.IsBound()) + if (!OnInsertUniqueI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI256")); } return false; } - OnInsertOptionString.Broadcast(Context, Args.S); + OnInsertUniqueI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOptionUuid(const FTestClientOptionalUuid& U) +void URemoteReducers::InsertUniqueI32(const int32 N, const int32 Data) { if (!Conn) { @@ -8634,45 +11830,45 @@ void URemoteReducers::InsertOptionUuid(const FTestClientOptionalUuid& U) return; } - FInsertOptionUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionUuid(ReducerArgs)); } + FInsertUniqueI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionUuid(const FReducerEventContext& Context, const UInsertOptionUuidReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI32(const FReducerEventContext& Context, const UInsertUniqueI32Reducer* Args) { - if (!OnInsertOptionUuid.IsBound()) + if (!OnInsertUniqueI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI32")); } return false; } - OnInsertOptionUuid.Broadcast(Context, Args->U); + OnInsertUniqueI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionUuidWithArgs(const FReducerEventContext& Context, const FInsertOptionUuidArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI32WithArgs(const FReducerEventContext& Context, const FInsertUniqueI32Args& Args) { - if (!OnInsertOptionUuid.IsBound()) + if (!OnInsertUniqueI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI32")); } return false; } - OnInsertOptionUuid.Broadcast(Context, Args.U); + OnInsertUniqueI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOptionVecOptionI32(const FTestClientOptionalVecOptionalInt32& V) +void URemoteReducers::InsertUniqueI64(const int64 N, const int32 Data) { if (!Conn) { @@ -8680,45 +11876,45 @@ void URemoteReducers::InsertOptionVecOptionI32(const FTestClientOptionalVecOptio return; } - FInsertOptionVecOptionI32Args ReducerArgs(V); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_vec_option_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionVecOptionI32(ReducerArgs)); } + FInsertUniqueI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionVecOptionI32(const FReducerEventContext& Context, const UInsertOptionVecOptionI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueI64(const FReducerEventContext& Context, const UInsertUniqueI64Reducer* Args) { - if (!OnInsertOptionVecOptionI32.IsBound()) + if (!OnInsertUniqueI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionVecOptionI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI64")); } return false; } - OnInsertOptionVecOptionI32.Broadcast(Context, Args->V); + OnInsertUniqueI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionVecOptionI32WithArgs(const FReducerEventContext& Context, const FInsertOptionVecOptionI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueI64WithArgs(const FReducerEventContext& Context, const FInsertUniqueI64Args& Args) { - if (!OnInsertOptionVecOptionI32.IsBound()) + if (!OnInsertUniqueI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionVecOptionI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI64")); } return false; } - OnInsertOptionVecOptionI32.Broadcast(Context, Args.V); + OnInsertUniqueI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkBool(const bool B, const int32 Data) +void URemoteReducers::InsertUniqueI8(const int8 N, const int32 Data) { if (!Conn) { @@ -8726,45 +11922,45 @@ void URemoteReducers::InsertPkBool(const bool B, const int32 Data) return; } - FInsertPkBoolArgs ReducerArgs(B, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkBool(ReducerArgs)); } + FInsertUniqueI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkBool(const FReducerEventContext& Context, const UInsertPkBoolReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI8(const FReducerEventContext& Context, const UInsertUniqueI8Reducer* Args) { - if (!OnInsertPkBool.IsBound()) + if (!OnInsertUniqueI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI8")); } return false; } - OnInsertPkBool.Broadcast(Context, Args->B, Args->Data); + OnInsertUniqueI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkBoolWithArgs(const FReducerEventContext& Context, const FInsertPkBoolArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI8WithArgs(const FReducerEventContext& Context, const FInsertUniqueI8Args& Args) { - if (!OnInsertPkBool.IsBound()) + if (!OnInsertUniqueI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI8")); } return false; } - OnInsertPkBool.Broadcast(Context, Args.B, Args.Data); + OnInsertUniqueI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) +void URemoteReducers::InsertUniqueIdentity(const FSpacetimeDBIdentity& I, const int32 Data) { if (!Conn) { @@ -8772,45 +11968,45 @@ void URemoteReducers::InsertPkConnectionId(const FSpacetimeDBConnectionId& A, co return; } - FInsertPkConnectionIdArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkConnectionId(ReducerArgs)); } + FInsertUniqueIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkConnectionId(const FReducerEventContext& Context, const UInsertPkConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertUniqueIdentity(const FReducerEventContext& Context, const UInsertUniqueIdentityReducer* Args) { - if (!OnInsertPkConnectionId.IsBound()) + if (!OnInsertUniqueIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueIdentity")); } return false; } - OnInsertPkConnectionId.Broadcast(Context, Args->A, Args->Data); + OnInsertUniqueIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertPkConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueIdentityArgs& Args) { - if (!OnInsertPkConnectionId.IsBound()) + if (!OnInsertUniqueIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueIdentity")); } return false; } - OnInsertPkConnectionId.Broadcast(Context, Args.A, Args.Data); + OnInsertUniqueIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::InsertPkI128(const FSpacetimeDBInt128& N, const int32 Data) +void URemoteReducers::InsertUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data) { if (!Conn) { @@ -8818,45 +12014,45 @@ void URemoteReducers::InsertPkI128(const FSpacetimeDBInt128& N, const int32 Data return; } - FInsertPkI128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI128(ReducerArgs)); } + FInsertUniqueOptionBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI128(const FReducerEventContext& Context, const UInsertPkI128Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionBool(const FReducerEventContext& Context, const UInsertUniqueOptionBoolReducer* Args) { - if (!OnInsertPkI128.IsBound()) + if (!OnInsertUniqueOptionBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionBool")); } return false; } - OnInsertPkI128.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI128WithArgs(const FReducerEventContext& Context, const FInsertPkI128Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionBoolArgs& Args) { - if (!OnInsertPkI128.IsBound()) + if (!OnInsertUniqueOptionBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionBool")); } return false; } - OnInsertPkI128.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::InsertPkI16(const int16 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data) { if (!Conn) { @@ -8864,45 +12060,45 @@ void URemoteReducers::InsertPkI16(const int16 N, const int32 Data) return; } - FInsertPkI16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI16(ReducerArgs)); } + FInsertUniqueOptionConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI16(const FReducerEventContext& Context, const UInsertPkI16Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionConnectionId(const FReducerEventContext& Context, const UInsertUniqueOptionConnectionIdReducer* Args) { - if (!OnInsertPkI16.IsBound()) + if (!OnInsertUniqueOptionConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionConnectionId")); } return false; } - OnInsertPkI16.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI16WithArgs(const FReducerEventContext& Context, const FInsertPkI16Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionConnectionIdArgs& Args) { - if (!OnInsertPkI16.IsBound()) + if (!OnInsertUniqueOptionConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionConnectionId")); } return false; } - OnInsertPkI16.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertPkI256(const FSpacetimeDBInt256& N, const int32 Data) +void URemoteReducers::InsertUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data) { if (!Conn) { @@ -8910,45 +12106,45 @@ void URemoteReducers::InsertPkI256(const FSpacetimeDBInt256& N, const int32 Data return; } - FInsertPkI256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI256(ReducerArgs)); } + FInsertUniqueOptionI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI256(const FReducerEventContext& Context, const UInsertPkI256Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI128(const FReducerEventContext& Context, const UInsertUniqueOptionI128Reducer* Args) { - if (!OnInsertPkI256.IsBound()) + if (!OnInsertUniqueOptionI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI128")); } return false; } - OnInsertPkI256.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI256WithArgs(const FReducerEventContext& Context, const FInsertPkI256Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI128Args& Args) { - if (!OnInsertPkI256.IsBound()) + if (!OnInsertUniqueOptionI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI128")); } return false; } - OnInsertPkI256.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkI32(const int32 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data) { if (!Conn) { @@ -8956,45 +12152,45 @@ void URemoteReducers::InsertPkI32(const int32 N, const int32 Data) return; } - FInsertPkI32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI32(ReducerArgs)); } + FInsertUniqueOptionI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI32(const FReducerEventContext& Context, const UInsertPkI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI16(const FReducerEventContext& Context, const UInsertUniqueOptionI16Reducer* Args) { - if (!OnInsertPkI32.IsBound()) + if (!OnInsertUniqueOptionI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI16")); } return false; } - OnInsertPkI32.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI32WithArgs(const FReducerEventContext& Context, const FInsertPkI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI16Args& Args) { - if (!OnInsertPkI32.IsBound()) + if (!OnInsertUniqueOptionI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI16")); } return false; } - OnInsertPkI32.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkI64(const int64 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data) { if (!Conn) { @@ -9002,45 +12198,45 @@ void URemoteReducers::InsertPkI64(const int64 N, const int32 Data) return; } - FInsertPkI64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI64(ReducerArgs)); } + FInsertUniqueOptionI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI64(const FReducerEventContext& Context, const UInsertPkI64Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI256(const FReducerEventContext& Context, const UInsertUniqueOptionI256Reducer* Args) { - if (!OnInsertPkI64.IsBound()) + if (!OnInsertUniqueOptionI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI256")); } return false; } - OnInsertPkI64.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI64WithArgs(const FReducerEventContext& Context, const FInsertPkI64Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI256Args& Args) { - if (!OnInsertPkI64.IsBound()) + if (!OnInsertUniqueOptionI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI256")); } return false; } - OnInsertPkI64.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkI8(const int8 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data) { if (!Conn) { @@ -9048,45 +12244,45 @@ void URemoteReducers::InsertPkI8(const int8 N, const int32 Data) return; } - FInsertPkI8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI8(ReducerArgs)); } + FInsertUniqueOptionI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI8(const FReducerEventContext& Context, const UInsertPkI8Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI32(const FReducerEventContext& Context, const UInsertUniqueOptionI32Reducer* Args) { - if (!OnInsertPkI8.IsBound()) + if (!OnInsertUniqueOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI32")); } return false; } - OnInsertPkI8.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI8WithArgs(const FReducerEventContext& Context, const FInsertPkI8Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI32Args& Args) { - if (!OnInsertPkI8.IsBound()) + if (!OnInsertUniqueOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI32")); } return false; } - OnInsertPkI8.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkIdentity(const FSpacetimeDBIdentity& I, const int32 Data) +void URemoteReducers::InsertUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data) { if (!Conn) { @@ -9094,45 +12290,45 @@ void URemoteReducers::InsertPkIdentity(const FSpacetimeDBIdentity& I, const int3 return; } - FInsertPkIdentityArgs ReducerArgs(I, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkIdentity(ReducerArgs)); } + FInsertUniqueOptionI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkIdentity(const FReducerEventContext& Context, const UInsertPkIdentityReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI64(const FReducerEventContext& Context, const UInsertUniqueOptionI64Reducer* Args) { - if (!OnInsertPkIdentity.IsBound()) + if (!OnInsertUniqueOptionI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI64")); } return false; } - OnInsertPkIdentity.Broadcast(Context, Args->I, Args->Data); + OnInsertUniqueOptionI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkIdentityWithArgs(const FReducerEventContext& Context, const FInsertPkIdentityArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI64Args& Args) { - if (!OnInsertPkIdentity.IsBound()) + if (!OnInsertUniqueOptionI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI64")); } return false; } - OnInsertPkIdentity.Broadcast(Context, Args.I, Args.Data); + OnInsertUniqueOptionI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkSimpleEnum(const ESimpleEnumType& A, const int32 Data) +void URemoteReducers::InsertUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data) { if (!Conn) { @@ -9140,45 +12336,45 @@ void URemoteReducers::InsertPkSimpleEnum(const ESimpleEnumType& A, const int32 D return; } - FInsertPkSimpleEnumArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkSimpleEnum(ReducerArgs)); } + FInsertUniqueOptionI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkSimpleEnum(const FReducerEventContext& Context, const UInsertPkSimpleEnumReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI8(const FReducerEventContext& Context, const UInsertUniqueOptionI8Reducer* Args) { - if (!OnInsertPkSimpleEnum.IsBound()) + if (!OnInsertUniqueOptionI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI8")); } return false; } - OnInsertPkSimpleEnum.Broadcast(Context, Args->A, Args->Data); + OnInsertUniqueOptionI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertPkSimpleEnumArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI8Args& Args) { - if (!OnInsertPkSimpleEnum.IsBound()) + if (!OnInsertUniqueOptionI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI8")); } return false; } - OnInsertPkSimpleEnum.Broadcast(Context, Args.A, Args.Data); + OnInsertUniqueOptionI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkString(const FString& S, const int32 Data) +void URemoteReducers::InsertUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data) { if (!Conn) { @@ -9186,45 +12382,45 @@ void URemoteReducers::InsertPkString(const FString& S, const int32 Data) return; } - FInsertPkStringArgs ReducerArgs(S, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkString(ReducerArgs)); } + FInsertUniqueOptionIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkString(const FReducerEventContext& Context, const UInsertPkStringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionIdentity(const FReducerEventContext& Context, const UInsertUniqueOptionIdentityReducer* Args) { - if (!OnInsertPkString.IsBound()) + if (!OnInsertUniqueOptionIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionIdentity")); } return false; } - OnInsertPkString.Broadcast(Context, Args->S, Args->Data); + OnInsertUniqueOptionIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkStringWithArgs(const FReducerEventContext& Context, const FInsertPkStringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionIdentityArgs& Args) { - if (!OnInsertPkString.IsBound()) + if (!OnInsertUniqueOptionIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionIdentity")); } return false; } - OnInsertPkString.Broadcast(Context, Args.S, Args.Data); + OnInsertUniqueOptionIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::InsertPkU128(const FSpacetimeDBUInt128& N, const int32 Data) +void URemoteReducers::InsertUniqueOptionString(const FTestClientOptionalString& S, const int32 Data) { if (!Conn) { @@ -9232,45 +12428,45 @@ void URemoteReducers::InsertPkU128(const FSpacetimeDBUInt128& N, const int32 Dat return; } - FInsertPkU128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU128(ReducerArgs)); } + FInsertUniqueOptionStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU128(const FReducerEventContext& Context, const UInsertPkU128Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionString(const FReducerEventContext& Context, const UInsertUniqueOptionStringReducer* Args) { - if (!OnInsertPkU128.IsBound()) + if (!OnInsertUniqueOptionString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionString")); } return false; } - OnInsertPkU128.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU128WithArgs(const FReducerEventContext& Context, const FInsertPkU128Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionStringArgs& Args) { - if (!OnInsertPkU128.IsBound()) + if (!OnInsertUniqueOptionString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionString")); } return false; } - OnInsertPkU128.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::InsertPkU16(const uint16 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data) { if (!Conn) { @@ -9278,45 +12474,45 @@ void URemoteReducers::InsertPkU16(const uint16 N, const int32 Data) return; } - FInsertPkU16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU16(ReducerArgs)); } + FInsertUniqueOptionU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU16(const FReducerEventContext& Context, const UInsertPkU16Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU128(const FReducerEventContext& Context, const UInsertUniqueOptionU128Reducer* Args) { - if (!OnInsertPkU16.IsBound()) + if (!OnInsertUniqueOptionU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU128")); } return false; } - OnInsertPkU16.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU16WithArgs(const FReducerEventContext& Context, const FInsertPkU16Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU128Args& Args) { - if (!OnInsertPkU16.IsBound()) + if (!OnInsertUniqueOptionU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU128")); } return false; } - OnInsertPkU16.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU256(const FSpacetimeDBUInt256& N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data) { if (!Conn) { @@ -9324,45 +12520,45 @@ void URemoteReducers::InsertPkU256(const FSpacetimeDBUInt256& N, const int32 Dat return; } - FInsertPkU256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU256(ReducerArgs)); } + FInsertUniqueOptionU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU256(const FReducerEventContext& Context, const UInsertPkU256Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU16(const FReducerEventContext& Context, const UInsertUniqueOptionU16Reducer* Args) { - if (!OnInsertPkU256.IsBound()) + if (!OnInsertUniqueOptionU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU16")); } return false; } - OnInsertPkU256.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU256WithArgs(const FReducerEventContext& Context, const FInsertPkU256Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU16Args& Args) { - if (!OnInsertPkU256.IsBound()) + if (!OnInsertUniqueOptionU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU16")); } return false; } - OnInsertPkU256.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU32(const uint32 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data) { if (!Conn) { @@ -9370,45 +12566,45 @@ void URemoteReducers::InsertPkU32(const uint32 N, const int32 Data) return; } - FInsertPkU32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU32(ReducerArgs)); } + FInsertUniqueOptionU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU32(const FReducerEventContext& Context, const UInsertPkU32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU256(const FReducerEventContext& Context, const UInsertUniqueOptionU256Reducer* Args) { - if (!OnInsertPkU32.IsBound()) + if (!OnInsertUniqueOptionU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU256")); } return false; } - OnInsertPkU32.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU32WithArgs(const FReducerEventContext& Context, const FInsertPkU32Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU256Args& Args) { - if (!OnInsertPkU32.IsBound()) + if (!OnInsertUniqueOptionU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU256")); } return false; } - OnInsertPkU32.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU32Two(const uint32 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data) { if (!Conn) { @@ -9416,45 +12612,45 @@ void URemoteReducers::InsertPkU32Two(const uint32 N, const int32 Data) return; } - FInsertPkU32TwoArgs ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_32_two"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU32Two(ReducerArgs)); } + FInsertUniqueOptionU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU32Two(const FReducerEventContext& Context, const UInsertPkU32TwoReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU32(const FReducerEventContext& Context, const UInsertUniqueOptionU32Reducer* Args) { - if (!OnInsertPkU32Two.IsBound()) + if (!OnInsertUniqueOptionU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU32")); } return false; } - OnInsertPkU32Two.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU32TwoWithArgs(const FReducerEventContext& Context, const FInsertPkU32TwoArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU32Args& Args) { - if (!OnInsertPkU32Two.IsBound()) + if (!OnInsertUniqueOptionU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU32")); } return false; } - OnInsertPkU32Two.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU64(const uint64 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data) { if (!Conn) { @@ -9462,45 +12658,45 @@ void URemoteReducers::InsertPkU64(const uint64 N, const int32 Data) return; } - FInsertPkU64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU64(ReducerArgs)); } + FInsertUniqueOptionU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU64(const FReducerEventContext& Context, const UInsertPkU64Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU64(const FReducerEventContext& Context, const UInsertUniqueOptionU64Reducer* Args) { - if (!OnInsertPkU64.IsBound()) + if (!OnInsertUniqueOptionU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU64")); } return false; } - OnInsertPkU64.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU64WithArgs(const FReducerEventContext& Context, const FInsertPkU64Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU64Args& Args) { - if (!OnInsertPkU64.IsBound()) + if (!OnInsertUniqueOptionU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU64")); } return false; } - OnInsertPkU64.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU8(const uint8 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data) { if (!Conn) { @@ -9508,45 +12704,45 @@ void URemoteReducers::InsertPkU8(const uint8 N, const int32 Data) return; } - FInsertPkU8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU8(ReducerArgs)); } + FInsertUniqueOptionU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU8(const FReducerEventContext& Context, const UInsertPkU8Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU8(const FReducerEventContext& Context, const UInsertUniqueOptionU8Reducer* Args) { - if (!OnInsertPkU8.IsBound()) + if (!OnInsertUniqueOptionU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU8")); } return false; } - OnInsertPkU8.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU8WithArgs(const FReducerEventContext& Context, const FInsertPkU8Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU8Args& Args) { - if (!OnInsertPkU8.IsBound()) + if (!OnInsertUniqueOptionU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU8")); } return false; } - OnInsertPkU8.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkUuid(const FSpacetimeDBUuid& U, const int32 Data) +void URemoteReducers::InsertUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data) { if (!Conn) { @@ -9554,45 +12750,45 @@ void URemoteReducers::InsertPkUuid(const FSpacetimeDBUuid& U, const int32 Data) return; } - FInsertPkUuidArgs ReducerArgs(U, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkUuid(ReducerArgs)); } + FInsertUniqueOptionUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkUuid(const FReducerEventContext& Context, const UInsertPkUuidReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionUuid(const FReducerEventContext& Context, const UInsertUniqueOptionUuidReducer* Args) { - if (!OnInsertPkUuid.IsBound()) + if (!OnInsertUniqueOptionUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionUuid")); } return false; } - OnInsertPkUuid.Broadcast(Context, Args->U, Args->Data); + OnInsertUniqueOptionUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkUuidWithArgs(const FReducerEventContext& Context, const FInsertPkUuidArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionUuidArgs& Args) { - if (!OnInsertPkUuid.IsBound()) + if (!OnInsertUniqueOptionUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionUuid")); } return false; } - OnInsertPkUuid.Broadcast(Context, Args.U, Args.Data); + OnInsertUniqueOptionUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::InsertPrimitivesAsStrings(const FEveryPrimitiveStructType& S) +void URemoteReducers::InsertUniqueString(const FString& S, const int32 Data) { if (!Conn) { @@ -9600,45 +12796,45 @@ void URemoteReducers::InsertPrimitivesAsStrings(const FEveryPrimitiveStructType& return; } - FInsertPrimitivesAsStringsArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_primitives_as_strings"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPrimitivesAsStrings(ReducerArgs)); } + FInsertUniqueStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPrimitivesAsStrings(const FReducerEventContext& Context, const UInsertPrimitivesAsStringsReducer* Args) +bool URemoteReducers::InvokeInsertUniqueString(const FReducerEventContext& Context, const UInsertUniqueStringReducer* Args) { - if (!OnInsertPrimitivesAsStrings.IsBound()) + if (!OnInsertUniqueString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPrimitivesAsStrings")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueString")); } return false; } - OnInsertPrimitivesAsStrings.Broadcast(Context, Args->S); + OnInsertUniqueString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPrimitivesAsStringsWithArgs(const FReducerEventContext& Context, const FInsertPrimitivesAsStringsArgs& Args) +bool URemoteReducers::InvokeInsertUniqueStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueStringArgs& Args) { - if (!OnInsertPrimitivesAsStrings.IsBound()) + if (!OnInsertUniqueString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPrimitivesAsStrings")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueString")); } return false; } - OnInsertPrimitivesAsStrings.Broadcast(Context, Args.S); + OnInsertUniqueString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::InsertResultEveryPrimitiveStructString(const FTestClientResultEveryPrimitiveStructString& R) +void URemoteReducers::InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data) { if (!Conn) { @@ -9646,45 +12842,45 @@ void URemoteReducers::InsertResultEveryPrimitiveStructString(const FTestClientRe return; } - FInsertResultEveryPrimitiveStructStringArgs ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_every_primitive_struct_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultEveryPrimitiveStructString(ReducerArgs)); } + FInsertUniqueU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultEveryPrimitiveStructString(const FReducerEventContext& Context, const UInsertResultEveryPrimitiveStructStringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU128(const FReducerEventContext& Context, const UInsertUniqueU128Reducer* Args) { - if (!OnInsertResultEveryPrimitiveStructString.IsBound()) + if (!OnInsertUniqueU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultEveryPrimitiveStructString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU128")); } return false; } - OnInsertResultEveryPrimitiveStructString.Broadcast(Context, Args->R); + OnInsertUniqueU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultEveryPrimitiveStructStringWithArgs(const FReducerEventContext& Context, const FInsertResultEveryPrimitiveStructStringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueU128Args& Args) { - if (!OnInsertResultEveryPrimitiveStructString.IsBound()) + if (!OnInsertUniqueU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultEveryPrimitiveStructString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU128")); } return false; } - OnInsertResultEveryPrimitiveStructString.Broadcast(Context, Args.R); + OnInsertUniqueU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertResultI32String(const FTestClientResultInt32String& R) +void URemoteReducers::InsertUniqueU16(const uint16 N, const int32 Data) { if (!Conn) { @@ -9692,45 +12888,45 @@ void URemoteReducers::InsertResultI32String(const FTestClientResultInt32String& return; } - FInsertResultI32StringArgs ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_i_32_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultI32String(ReducerArgs)); } + FInsertUniqueU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultI32String(const FReducerEventContext& Context, const UInsertResultI32StringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU16(const FReducerEventContext& Context, const UInsertUniqueU16Reducer* Args) { - if (!OnInsertResultI32String.IsBound()) + if (!OnInsertUniqueU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultI32String")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU16")); } return false; } - OnInsertResultI32String.Broadcast(Context, Args->R); + OnInsertUniqueU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultI32StringWithArgs(const FReducerEventContext& Context, const FInsertResultI32StringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueU16Args& Args) { - if (!OnInsertResultI32String.IsBound()) + if (!OnInsertUniqueU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultI32String")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU16")); } return false; } - OnInsertResultI32String.Broadcast(Context, Args.R); + OnInsertUniqueU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertResultIdentityString(const FTestClientResultIdentityString& R) +void URemoteReducers::InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data) { if (!Conn) { @@ -9738,45 +12934,45 @@ void URemoteReducers::InsertResultIdentityString(const FTestClientResultIdentity return; } - FInsertResultIdentityStringArgs ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_identity_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultIdentityString(ReducerArgs)); } + FInsertUniqueU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultIdentityString(const FReducerEventContext& Context, const UInsertResultIdentityStringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU256(const FReducerEventContext& Context, const UInsertUniqueU256Reducer* Args) { - if (!OnInsertResultIdentityString.IsBound()) + if (!OnInsertUniqueU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultIdentityString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU256")); } return false; } - OnInsertResultIdentityString.Broadcast(Context, Args->R); + OnInsertUniqueU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultIdentityStringWithArgs(const FReducerEventContext& Context, const FInsertResultIdentityStringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueU256Args& Args) { - if (!OnInsertResultIdentityString.IsBound()) + if (!OnInsertUniqueU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultIdentityString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU256")); } return false; } - OnInsertResultIdentityString.Broadcast(Context, Args.R); + OnInsertUniqueU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertResultSimpleEnumI32(const FTestClientResultSimpleEnumInt32& R) +void URemoteReducers::InsertUniqueU32(const uint32 N, const int32 Data) { if (!Conn) { @@ -9784,45 +12980,45 @@ void URemoteReducers::InsertResultSimpleEnumI32(const FTestClientResultSimpleEnu return; } - FInsertResultSimpleEnumI32Args ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_simple_enum_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultSimpleEnumI32(ReducerArgs)); } + FInsertUniqueU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultSimpleEnumI32(const FReducerEventContext& Context, const UInsertResultSimpleEnumI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueU32(const FReducerEventContext& Context, const UInsertUniqueU32Reducer* Args) { - if (!OnInsertResultSimpleEnumI32.IsBound()) + if (!OnInsertUniqueU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultSimpleEnumI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32")); } return false; } - OnInsertResultSimpleEnumI32.Broadcast(Context, Args->R); + OnInsertUniqueU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultSimpleEnumI32WithArgs(const FReducerEventContext& Context, const FInsertResultSimpleEnumI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32Args& Args) { - if (!OnInsertResultSimpleEnumI32.IsBound()) + if (!OnInsertUniqueU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultSimpleEnumI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32")); } return false; } - OnInsertResultSimpleEnumI32.Broadcast(Context, Args.R); + OnInsertUniqueU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertResultStringI32(const FTestClientResultStringInt32& R) +void URemoteReducers::InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUnique, const int32 DPk) { if (!Conn) { @@ -9830,45 +13026,45 @@ void URemoteReducers::InsertResultStringI32(const FTestClientResultStringInt32& return; } - FInsertResultStringI32Args ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_string_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultStringI32(ReducerArgs)); } + FInsertUniqueU32UpdatePkU32Args ReducerArgs(N, DUnique, DPk); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_32_update_pk_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU32UpdatePkU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultStringI32(const FReducerEventContext& Context, const UInsertResultStringI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueU32UpdatePkU32(const FReducerEventContext& Context, const UInsertUniqueU32UpdatePkU32Reducer* Args) { - if (!OnInsertResultStringI32.IsBound()) + if (!OnInsertUniqueU32UpdatePkU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultStringI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32UpdatePkU32")); } return false; } - OnInsertResultStringI32.Broadcast(Context, Args->R); + OnInsertUniqueU32UpdatePkU32.Broadcast(Context, Args->N, Args->DUnique, Args->DPk); return true; } -bool URemoteReducers::InvokeInsertResultStringI32WithArgs(const FReducerEventContext& Context, const FInsertResultStringI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueU32UpdatePkU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32UpdatePkU32Args& Args) { - if (!OnInsertResultStringI32.IsBound()) + if (!OnInsertUniqueU32UpdatePkU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultStringI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32UpdatePkU32")); } return false; } - OnInsertResultStringI32.Broadcast(Context, Args.R); + OnInsertUniqueU32UpdatePkU32.Broadcast(Context, Args.N, Args.DUnique, Args.DPk); return true; } -void URemoteReducers::InsertResultVecI32String(const FTestClientResultVecInt32String& R) +void URemoteReducers::InsertUniqueU64(const uint64 N, const int32 Data) { if (!Conn) { @@ -9876,45 +13072,45 @@ void URemoteReducers::InsertResultVecI32String(const FTestClientResultVecInt32St return; } - FInsertResultVecI32StringArgs ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_vec_i_32_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultVecI32String(ReducerArgs)); } + FInsertUniqueU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultVecI32String(const FReducerEventContext& Context, const UInsertResultVecI32StringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU64(const FReducerEventContext& Context, const UInsertUniqueU64Reducer* Args) { - if (!OnInsertResultVecI32String.IsBound()) + if (!OnInsertUniqueU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultVecI32String")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU64")); } return false; } - OnInsertResultVecI32String.Broadcast(Context, Args->R); + OnInsertUniqueU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultVecI32StringWithArgs(const FReducerEventContext& Context, const FInsertResultVecI32StringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueU64Args& Args) { - if (!OnInsertResultVecI32String.IsBound()) + if (!OnInsertUniqueU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultVecI32String")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU64")); } return false; } - OnInsertResultVecI32String.Broadcast(Context, Args.R); + OnInsertUniqueU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertTableHoldsTable(const FOneU8Type& A, const FVecU8Type& B) +void URemoteReducers::InsertUniqueU8(const uint8 N, const int32 Data) { if (!Conn) { @@ -9922,45 +13118,45 @@ void URemoteReducers::InsertTableHoldsTable(const FOneU8Type& A, const FVecU8Typ return; } - FInsertTableHoldsTableArgs ReducerArgs(A, B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_table_holds_table"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertTableHoldsTable(ReducerArgs)); } + FInsertUniqueU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertTableHoldsTable(const FReducerEventContext& Context, const UInsertTableHoldsTableReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU8(const FReducerEventContext& Context, const UInsertUniqueU8Reducer* Args) { - if (!OnInsertTableHoldsTable.IsBound()) + if (!OnInsertUniqueU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertTableHoldsTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU8")); } return false; } - OnInsertTableHoldsTable.Broadcast(Context, Args->A, Args->B); + OnInsertUniqueU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertTableHoldsTableWithArgs(const FReducerEventContext& Context, const FInsertTableHoldsTableArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU8WithArgs(const FReducerEventContext& Context, const FInsertUniqueU8Args& Args) { - if (!OnInsertTableHoldsTable.IsBound()) + if (!OnInsertUniqueU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertTableHoldsTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU8")); } return false; } - OnInsertTableHoldsTable.Broadcast(Context, Args.A, Args.B); + OnInsertUniqueU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertUniqueBool(const bool B, const int32 Data) +void URemoteReducers::InsertUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data) { if (!Conn) { @@ -9968,45 +13164,45 @@ void URemoteReducers::InsertUniqueBool(const bool B, const int32 Data) return; } - FInsertUniqueBoolArgs ReducerArgs(B, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueBool(ReducerArgs)); } + FInsertUniqueUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueBool(const FReducerEventContext& Context, const UInsertUniqueBoolReducer* Args) +bool URemoteReducers::InvokeInsertUniqueUuid(const FReducerEventContext& Context, const UInsertUniqueUuidReducer* Args) { - if (!OnInsertUniqueBool.IsBound()) + if (!OnInsertUniqueUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueUuid")); } return false; } - OnInsertUniqueBool.Broadcast(Context, Args->B, Args->Data); + OnInsertUniqueUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeInsertUniqueBoolWithArgs(const FReducerEventContext& Context, const FInsertUniqueBoolArgs& Args) +bool URemoteReducers::InvokeInsertUniqueUuidWithArgs(const FReducerEventContext& Context, const FInsertUniqueUuidArgs& Args) { - if (!OnInsertUniqueBool.IsBound()) + if (!OnInsertUniqueUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueUuid")); } return false; } - OnInsertUniqueBool.Broadcast(Context, Args.B, Args.Data); + OnInsertUniqueUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::InsertUniqueConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) +void URemoteReducers::InsertUser(const FString& Name, const FSpacetimeDBIdentity& Identity) { if (!Conn) { @@ -10014,45 +13210,45 @@ void URemoteReducers::InsertUniqueConnectionId(const FSpacetimeDBConnectionId& A return; } - FInsertUniqueConnectionIdArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueConnectionId(ReducerArgs)); } + FInsertUserArgs ReducerArgs(Name, Identity); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_user"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUser(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueConnectionId(const FReducerEventContext& Context, const UInsertUniqueConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertUser(const FReducerEventContext& Context, const UInsertUserReducer* Args) { - if (!OnInsertUniqueConnectionId.IsBound()) + if (!OnInsertUser.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUser")); } return false; } - OnInsertUniqueConnectionId.Broadcast(Context, Args->A, Args->Data); + OnInsertUser.Broadcast(Context, Args->Name, Args->Identity); return true; } -bool URemoteReducers::InvokeInsertUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertUniqueConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertUserWithArgs(const FReducerEventContext& Context, const FInsertUserArgs& Args) { - if (!OnInsertUniqueConnectionId.IsBound()) + if (!OnInsertUser.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUser")); } return false; } - OnInsertUniqueConnectionId.Broadcast(Context, Args.A, Args.Data); + OnInsertUser.Broadcast(Context, Args.Name, Args.Identity); return true; } -void URemoteReducers::InsertUniqueI128(const FSpacetimeDBInt128& N, const int32 Data) +void URemoteReducers::InsertVecBool(const TArray& B) { if (!Conn) { @@ -10060,45 +13256,45 @@ void URemoteReducers::InsertUniqueI128(const FSpacetimeDBInt128& N, const int32 return; } - FInsertUniqueI128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI128(ReducerArgs)); } + FInsertVecBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI128(const FReducerEventContext& Context, const UInsertUniqueI128Reducer* Args) +bool URemoteReducers::InvokeInsertVecBool(const FReducerEventContext& Context, const UInsertVecBoolReducer* Args) { - if (!OnInsertUniqueI128.IsBound()) + if (!OnInsertVecBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecBool")); } return false; } - OnInsertUniqueI128.Broadcast(Context, Args->N, Args->Data); + OnInsertVecBool.Broadcast(Context, Args->B); return true; } -bool URemoteReducers::InvokeInsertUniqueI128WithArgs(const FReducerEventContext& Context, const FInsertUniqueI128Args& Args) +bool URemoteReducers::InvokeInsertVecBoolWithArgs(const FReducerEventContext& Context, const FInsertVecBoolArgs& Args) { - if (!OnInsertUniqueI128.IsBound()) + if (!OnInsertVecBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecBool")); } return false; } - OnInsertUniqueI128.Broadcast(Context, Args.N, Args.Data); + OnInsertVecBool.Broadcast(Context, Args.B); return true; } -void URemoteReducers::InsertUniqueI16(const int16 N, const int32 Data) +void URemoteReducers::InsertVecByteStruct(const TArray& S) { if (!Conn) { @@ -10106,45 +13302,45 @@ void URemoteReducers::InsertUniqueI16(const int16 N, const int32 Data) return; } - FInsertUniqueI16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI16(ReducerArgs)); } + FInsertVecByteStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_byte_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecByteStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI16(const FReducerEventContext& Context, const UInsertUniqueI16Reducer* Args) +bool URemoteReducers::InvokeInsertVecByteStruct(const FReducerEventContext& Context, const UInsertVecByteStructReducer* Args) { - if (!OnInsertUniqueI16.IsBound()) + if (!OnInsertVecByteStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecByteStruct")); } return false; } - OnInsertUniqueI16.Broadcast(Context, Args->N, Args->Data); + OnInsertVecByteStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertUniqueI16WithArgs(const FReducerEventContext& Context, const FInsertUniqueI16Args& Args) +bool URemoteReducers::InvokeInsertVecByteStructWithArgs(const FReducerEventContext& Context, const FInsertVecByteStructArgs& Args) { - if (!OnInsertUniqueI16.IsBound()) + if (!OnInsertVecByteStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecByteStruct")); } return false; } - OnInsertUniqueI16.Broadcast(Context, Args.N, Args.Data); + OnInsertVecByteStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertUniqueI256(const FSpacetimeDBInt256& N, const int32 Data) +void URemoteReducers::InsertVecConnectionId(const TArray& A) { if (!Conn) { @@ -10152,45 +13348,45 @@ void URemoteReducers::InsertUniqueI256(const FSpacetimeDBInt256& N, const int32 return; } - FInsertUniqueI256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI256(ReducerArgs)); } + FInsertVecConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI256(const FReducerEventContext& Context, const UInsertUniqueI256Reducer* Args) +bool URemoteReducers::InvokeInsertVecConnectionId(const FReducerEventContext& Context, const UInsertVecConnectionIdReducer* Args) { - if (!OnInsertUniqueI256.IsBound()) + if (!OnInsertVecConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecConnectionId")); } return false; } - OnInsertUniqueI256.Broadcast(Context, Args->N, Args->Data); + OnInsertVecConnectionId.Broadcast(Context, Args->A); return true; } -bool URemoteReducers::InvokeInsertUniqueI256WithArgs(const FReducerEventContext& Context, const FInsertUniqueI256Args& Args) +bool URemoteReducers::InvokeInsertVecConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertVecConnectionIdArgs& Args) { - if (!OnInsertUniqueI256.IsBound()) + if (!OnInsertVecConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecConnectionId")); } return false; } - OnInsertUniqueI256.Broadcast(Context, Args.N, Args.Data); + OnInsertVecConnectionId.Broadcast(Context, Args.A); return true; } -void URemoteReducers::InsertUniqueI32(const int32 N, const int32 Data) +void URemoteReducers::InsertVecEnumWithPayload(const TArray& E) { if (!Conn) { @@ -10198,45 +13394,45 @@ void URemoteReducers::InsertUniqueI32(const int32 N, const int32 Data) return; } - FInsertUniqueI32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI32(ReducerArgs)); } + FInsertVecEnumWithPayloadArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_enum_with_payload"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEnumWithPayload(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI32(const FReducerEventContext& Context, const UInsertUniqueI32Reducer* Args) +bool URemoteReducers::InvokeInsertVecEnumWithPayload(const FReducerEventContext& Context, const UInsertVecEnumWithPayloadReducer* Args) { - if (!OnInsertUniqueI32.IsBound()) + if (!OnInsertVecEnumWithPayload.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEnumWithPayload")); } return false; } - OnInsertUniqueI32.Broadcast(Context, Args->N, Args->Data); + OnInsertVecEnumWithPayload.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeInsertUniqueI32WithArgs(const FReducerEventContext& Context, const FInsertUniqueI32Args& Args) +bool URemoteReducers::InvokeInsertVecEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FInsertVecEnumWithPayloadArgs& Args) { - if (!OnInsertUniqueI32.IsBound()) + if (!OnInsertVecEnumWithPayload.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEnumWithPayload")); } return false; } - OnInsertUniqueI32.Broadcast(Context, Args.N, Args.Data); + OnInsertVecEnumWithPayload.Broadcast(Context, Args.E); return true; } -void URemoteReducers::InsertUniqueI64(const int64 N, const int32 Data) +void URemoteReducers::InsertVecEveryPrimitiveStruct(const TArray& S) { if (!Conn) { @@ -10244,45 +13440,45 @@ void URemoteReducers::InsertUniqueI64(const int64 N, const int32 Data) return; } - FInsertUniqueI64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI64(ReducerArgs)); } + FInsertVecEveryPrimitiveStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_every_primitive_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEveryPrimitiveStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI64(const FReducerEventContext& Context, const UInsertUniqueI64Reducer* Args) +bool URemoteReducers::InvokeInsertVecEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertVecEveryPrimitiveStructReducer* Args) { - if (!OnInsertUniqueI64.IsBound()) + if (!OnInsertVecEveryPrimitiveStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryPrimitiveStruct")); } return false; } - OnInsertUniqueI64.Broadcast(Context, Args->N, Args->Data); + OnInsertVecEveryPrimitiveStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertUniqueI64WithArgs(const FReducerEventContext& Context, const FInsertUniqueI64Args& Args) +bool URemoteReducers::InvokeInsertVecEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertVecEveryPrimitiveStructArgs& Args) { - if (!OnInsertUniqueI64.IsBound()) + if (!OnInsertVecEveryPrimitiveStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryPrimitiveStruct")); } return false; } - OnInsertUniqueI64.Broadcast(Context, Args.N, Args.Data); + OnInsertVecEveryPrimitiveStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertUniqueI8(const int8 N, const int32 Data) +void URemoteReducers::InsertVecEveryVecStruct(const TArray& S) { if (!Conn) { @@ -10290,45 +13486,45 @@ void URemoteReducers::InsertUniqueI8(const int8 N, const int32 Data) return; } - FInsertUniqueI8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI8(ReducerArgs)); } + FInsertVecEveryVecStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_every_vec_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEveryVecStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI8(const FReducerEventContext& Context, const UInsertUniqueI8Reducer* Args) +bool URemoteReducers::InvokeInsertVecEveryVecStruct(const FReducerEventContext& Context, const UInsertVecEveryVecStructReducer* Args) { - if (!OnInsertUniqueI8.IsBound()) + if (!OnInsertVecEveryVecStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryVecStruct")); } return false; } - OnInsertUniqueI8.Broadcast(Context, Args->N, Args->Data); + OnInsertVecEveryVecStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertUniqueI8WithArgs(const FReducerEventContext& Context, const FInsertUniqueI8Args& Args) +bool URemoteReducers::InvokeInsertVecEveryVecStructWithArgs(const FReducerEventContext& Context, const FInsertVecEveryVecStructArgs& Args) { - if (!OnInsertUniqueI8.IsBound()) + if (!OnInsertVecEveryVecStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryVecStruct")); } return false; } - OnInsertUniqueI8.Broadcast(Context, Args.N, Args.Data); + OnInsertVecEveryVecStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertUniqueIdentity(const FSpacetimeDBIdentity& I, const int32 Data) +void URemoteReducers::InsertVecF32(const TArray& F) { if (!Conn) { @@ -10336,45 +13532,45 @@ void URemoteReducers::InsertUniqueIdentity(const FSpacetimeDBIdentity& I, const return; } - FInsertUniqueIdentityArgs ReducerArgs(I, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueIdentity(ReducerArgs)); } + FInsertVecF32Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_f_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecF32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueIdentity(const FReducerEventContext& Context, const UInsertUniqueIdentityReducer* Args) +bool URemoteReducers::InvokeInsertVecF32(const FReducerEventContext& Context, const UInsertVecF32Reducer* Args) { - if (!OnInsertUniqueIdentity.IsBound()) + if (!OnInsertVecF32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF32")); } return false; } - OnInsertUniqueIdentity.Broadcast(Context, Args->I, Args->Data); + OnInsertVecF32.Broadcast(Context, Args->F); return true; } -bool URemoteReducers::InvokeInsertUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueIdentityArgs& Args) +bool URemoteReducers::InvokeInsertVecF32WithArgs(const FReducerEventContext& Context, const FInsertVecF32Args& Args) { - if (!OnInsertUniqueIdentity.IsBound()) + if (!OnInsertVecF32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF32")); } return false; } - OnInsertUniqueIdentity.Broadcast(Context, Args.I, Args.Data); + OnInsertVecF32.Broadcast(Context, Args.F); return true; } -void URemoteReducers::InsertUniqueString(const FString& S, const int32 Data) +void URemoteReducers::InsertVecF64(const TArray& F) { if (!Conn) { @@ -10382,45 +13578,45 @@ void URemoteReducers::InsertUniqueString(const FString& S, const int32 Data) return; } - FInsertUniqueStringArgs ReducerArgs(S, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueString(ReducerArgs)); } + FInsertVecF64Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_f_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecF64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueString(const FReducerEventContext& Context, const UInsertUniqueStringReducer* Args) +bool URemoteReducers::InvokeInsertVecF64(const FReducerEventContext& Context, const UInsertVecF64Reducer* Args) { - if (!OnInsertUniqueString.IsBound()) + if (!OnInsertVecF64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF64")); } return false; } - OnInsertUniqueString.Broadcast(Context, Args->S, Args->Data); + OnInsertVecF64.Broadcast(Context, Args->F); return true; } -bool URemoteReducers::InvokeInsertUniqueStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueStringArgs& Args) +bool URemoteReducers::InvokeInsertVecF64WithArgs(const FReducerEventContext& Context, const FInsertVecF64Args& Args) { - if (!OnInsertUniqueString.IsBound()) + if (!OnInsertVecF64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF64")); } return false; } - OnInsertUniqueString.Broadcast(Context, Args.S, Args.Data); + OnInsertVecF64.Broadcast(Context, Args.F); return true; } -void URemoteReducers::InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data) +void URemoteReducers::InsertVecI128(const TArray& N) { if (!Conn) { @@ -10428,45 +13624,45 @@ void URemoteReducers::InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 return; } - FInsertUniqueU128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU128(ReducerArgs)); } + FInsertVecI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU128(const FReducerEventContext& Context, const UInsertUniqueU128Reducer* Args) +bool URemoteReducers::InvokeInsertVecI128(const FReducerEventContext& Context, const UInsertVecI128Reducer* Args) { - if (!OnInsertUniqueU128.IsBound()) + if (!OnInsertVecI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI128")); } return false; } - OnInsertUniqueU128.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI128.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueU128Args& Args) +bool URemoteReducers::InvokeInsertVecI128WithArgs(const FReducerEventContext& Context, const FInsertVecI128Args& Args) { - if (!OnInsertUniqueU128.IsBound()) + if (!OnInsertVecI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI128")); } return false; } - OnInsertUniqueU128.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI128.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU16(const uint16 N, const int32 Data) +void URemoteReducers::InsertVecI16(const TArray& N) { if (!Conn) { @@ -10474,45 +13670,45 @@ void URemoteReducers::InsertUniqueU16(const uint16 N, const int32 Data) return; } - FInsertUniqueU16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU16(ReducerArgs)); } + FInsertVecI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU16(const FReducerEventContext& Context, const UInsertUniqueU16Reducer* Args) +bool URemoteReducers::InvokeInsertVecI16(const FReducerEventContext& Context, const UInsertVecI16Reducer* Args) { - if (!OnInsertUniqueU16.IsBound()) + if (!OnInsertVecI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI16")); } return false; } - OnInsertUniqueU16.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI16.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueU16Args& Args) +bool URemoteReducers::InvokeInsertVecI16WithArgs(const FReducerEventContext& Context, const FInsertVecI16Args& Args) { - if (!OnInsertUniqueU16.IsBound()) + if (!OnInsertVecI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI16")); } return false; } - OnInsertUniqueU16.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI16.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data) +void URemoteReducers::InsertVecI256(const TArray& N) { if (!Conn) { @@ -10520,45 +13716,45 @@ void URemoteReducers::InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 return; } - FInsertUniqueU256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU256(ReducerArgs)); } + FInsertVecI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU256(const FReducerEventContext& Context, const UInsertUniqueU256Reducer* Args) +bool URemoteReducers::InvokeInsertVecI256(const FReducerEventContext& Context, const UInsertVecI256Reducer* Args) { - if (!OnInsertUniqueU256.IsBound()) + if (!OnInsertVecI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI256")); } return false; } - OnInsertUniqueU256.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueU256Args& Args) +bool URemoteReducers::InvokeInsertVecI256WithArgs(const FReducerEventContext& Context, const FInsertVecI256Args& Args) { - if (!OnInsertUniqueU256.IsBound()) + if (!OnInsertVecI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI256")); } return false; } - OnInsertUniqueU256.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU32(const uint32 N, const int32 Data) +void URemoteReducers::InsertVecI32(const TArray& N) { if (!Conn) { @@ -10566,45 +13762,45 @@ void URemoteReducers::InsertUniqueU32(const uint32 N, const int32 Data) return; } - FInsertUniqueU32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU32(ReducerArgs)); } + FInsertVecI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU32(const FReducerEventContext& Context, const UInsertUniqueU32Reducer* Args) +bool URemoteReducers::InvokeInsertVecI32(const FReducerEventContext& Context, const UInsertVecI32Reducer* Args) { - if (!OnInsertUniqueU32.IsBound()) + if (!OnInsertVecI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI32")); } return false; } - OnInsertUniqueU32.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32Args& Args) +bool URemoteReducers::InvokeInsertVecI32WithArgs(const FReducerEventContext& Context, const FInsertVecI32Args& Args) { - if (!OnInsertUniqueU32.IsBound()) + if (!OnInsertVecI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI32")); } return false; } - OnInsertUniqueU32.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUnique, const int32 DPk) +void URemoteReducers::InsertVecI64(const TArray& N) { if (!Conn) { @@ -10612,45 +13808,45 @@ void URemoteReducers::InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUn return; } - FInsertUniqueU32UpdatePkU32Args ReducerArgs(N, DUnique, DPk); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_32_update_pk_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU32UpdatePkU32(ReducerArgs)); } + FInsertVecI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU32UpdatePkU32(const FReducerEventContext& Context, const UInsertUniqueU32UpdatePkU32Reducer* Args) +bool URemoteReducers::InvokeInsertVecI64(const FReducerEventContext& Context, const UInsertVecI64Reducer* Args) { - if (!OnInsertUniqueU32UpdatePkU32.IsBound()) + if (!OnInsertVecI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32UpdatePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI64")); } return false; } - OnInsertUniqueU32UpdatePkU32.Broadcast(Context, Args->N, Args->DUnique, Args->DPk); + OnInsertVecI64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU32UpdatePkU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32UpdatePkU32Args& Args) +bool URemoteReducers::InvokeInsertVecI64WithArgs(const FReducerEventContext& Context, const FInsertVecI64Args& Args) { - if (!OnInsertUniqueU32UpdatePkU32.IsBound()) + if (!OnInsertVecI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32UpdatePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI64")); } return false; } - OnInsertUniqueU32UpdatePkU32.Broadcast(Context, Args.N, Args.DUnique, Args.DPk); + OnInsertVecI64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU64(const uint64 N, const int32 Data) +void URemoteReducers::InsertVecI8(const TArray& N) { if (!Conn) { @@ -10658,45 +13854,45 @@ void URemoteReducers::InsertUniqueU64(const uint64 N, const int32 Data) return; } - FInsertUniqueU64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU64(ReducerArgs)); } + FInsertVecI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU64(const FReducerEventContext& Context, const UInsertUniqueU64Reducer* Args) +bool URemoteReducers::InvokeInsertVecI8(const FReducerEventContext& Context, const UInsertVecI8Reducer* Args) { - if (!OnInsertUniqueU64.IsBound()) + if (!OnInsertVecI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI8")); } return false; } - OnInsertUniqueU64.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueU64Args& Args) +bool URemoteReducers::InvokeInsertVecI8WithArgs(const FReducerEventContext& Context, const FInsertVecI8Args& Args) { - if (!OnInsertUniqueU64.IsBound()) + if (!OnInsertVecI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI8")); } return false; } - OnInsertUniqueU64.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU8(const uint8 N, const int32 Data) +void URemoteReducers::InsertVecIdentity(const TArray& I) { if (!Conn) { @@ -10704,45 +13900,45 @@ void URemoteReducers::InsertUniqueU8(const uint8 N, const int32 Data) return; } - FInsertUniqueU8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU8(ReducerArgs)); } + FInsertVecIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU8(const FReducerEventContext& Context, const UInsertUniqueU8Reducer* Args) +bool URemoteReducers::InvokeInsertVecIdentity(const FReducerEventContext& Context, const UInsertVecIdentityReducer* Args) { - if (!OnInsertUniqueU8.IsBound()) + if (!OnInsertVecIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecIdentity")); } return false; } - OnInsertUniqueU8.Broadcast(Context, Args->N, Args->Data); + OnInsertVecIdentity.Broadcast(Context, Args->I); return true; } -bool URemoteReducers::InvokeInsertUniqueU8WithArgs(const FReducerEventContext& Context, const FInsertUniqueU8Args& Args) +bool URemoteReducers::InvokeInsertVecIdentityWithArgs(const FReducerEventContext& Context, const FInsertVecIdentityArgs& Args) { - if (!OnInsertUniqueU8.IsBound()) + if (!OnInsertVecIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecIdentity")); } return false; } - OnInsertUniqueU8.Broadcast(Context, Args.N, Args.Data); + OnInsertVecIdentity.Broadcast(Context, Args.I); return true; } -void URemoteReducers::InsertUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data) +void URemoteReducers::InsertVecSimpleEnum(const TArray& E) { if (!Conn) { @@ -10750,45 +13946,45 @@ void URemoteReducers::InsertUniqueUuid(const FSpacetimeDBUuid& U, const int32 Da return; } - FInsertUniqueUuidArgs ReducerArgs(U, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueUuid(ReducerArgs)); } + FInsertVecSimpleEnumArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueUuid(const FReducerEventContext& Context, const UInsertUniqueUuidReducer* Args) +bool URemoteReducers::InvokeInsertVecSimpleEnum(const FReducerEventContext& Context, const UInsertVecSimpleEnumReducer* Args) { - if (!OnInsertUniqueUuid.IsBound()) + if (!OnInsertVecSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecSimpleEnum")); } return false; } - OnInsertUniqueUuid.Broadcast(Context, Args->U, Args->Data); + OnInsertVecSimpleEnum.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeInsertUniqueUuidWithArgs(const FReducerEventContext& Context, const FInsertUniqueUuidArgs& Args) +bool URemoteReducers::InvokeInsertVecSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertVecSimpleEnumArgs& Args) { - if (!OnInsertUniqueUuid.IsBound()) + if (!OnInsertVecSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecSimpleEnum")); } return false; } - OnInsertUniqueUuid.Broadcast(Context, Args.U, Args.Data); + OnInsertVecSimpleEnum.Broadcast(Context, Args.E); return true; } -void URemoteReducers::InsertUser(const FString& Name, const FSpacetimeDBIdentity& Identity) +void URemoteReducers::InsertVecString(const TArray& S) { if (!Conn) { @@ -10796,45 +13992,45 @@ void URemoteReducers::InsertUser(const FString& Name, const FSpacetimeDBIdentity return; } - FInsertUserArgs ReducerArgs(Name, Identity); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_user"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUser(ReducerArgs)); } + FInsertVecStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUser(const FReducerEventContext& Context, const UInsertUserReducer* Args) +bool URemoteReducers::InvokeInsertVecString(const FReducerEventContext& Context, const UInsertVecStringReducer* Args) { - if (!OnInsertUser.IsBound()) + if (!OnInsertVecString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUser")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecString")); } return false; } - OnInsertUser.Broadcast(Context, Args->Name, Args->Identity); + OnInsertVecString.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertUserWithArgs(const FReducerEventContext& Context, const FInsertUserArgs& Args) +bool URemoteReducers::InvokeInsertVecStringWithArgs(const FReducerEventContext& Context, const FInsertVecStringArgs& Args) { - if (!OnInsertUser.IsBound()) + if (!OnInsertVecString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUser")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecString")); } return false; } - OnInsertUser.Broadcast(Context, Args.Name, Args.Identity); + OnInsertVecString.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertVecBool(const TArray& B) +void URemoteReducers::InsertVecTimestamp(const TArray& T) { if (!Conn) { @@ -10842,45 +14038,45 @@ void URemoteReducers::InsertVecBool(const TArray& B) return; } - FInsertVecBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecBool(ReducerArgs)); } + FInsertVecTimestampArgs ReducerArgs(T); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_timestamp"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecTimestamp(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecBool(const FReducerEventContext& Context, const UInsertVecBoolReducer* Args) +bool URemoteReducers::InvokeInsertVecTimestamp(const FReducerEventContext& Context, const UInsertVecTimestampReducer* Args) { - if (!OnInsertVecBool.IsBound()) + if (!OnInsertVecTimestamp.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecTimestamp")); } return false; } - OnInsertVecBool.Broadcast(Context, Args->B); + OnInsertVecTimestamp.Broadcast(Context, Args->T); return true; } -bool URemoteReducers::InvokeInsertVecBoolWithArgs(const FReducerEventContext& Context, const FInsertVecBoolArgs& Args) +bool URemoteReducers::InvokeInsertVecTimestampWithArgs(const FReducerEventContext& Context, const FInsertVecTimestampArgs& Args) { - if (!OnInsertVecBool.IsBound()) + if (!OnInsertVecTimestamp.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecTimestamp")); } return false; } - OnInsertVecBool.Broadcast(Context, Args.B); + OnInsertVecTimestamp.Broadcast(Context, Args.T); return true; } -void URemoteReducers::InsertVecByteStruct(const TArray& S) +void URemoteReducers::InsertVecU128(const TArray& N) { if (!Conn) { @@ -10888,45 +14084,45 @@ void URemoteReducers::InsertVecByteStruct(const TArray& S) return; } - FInsertVecByteStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_byte_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecByteStruct(ReducerArgs)); } + FInsertVecU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecByteStruct(const FReducerEventContext& Context, const UInsertVecByteStructReducer* Args) +bool URemoteReducers::InvokeInsertVecU128(const FReducerEventContext& Context, const UInsertVecU128Reducer* Args) { - if (!OnInsertVecByteStruct.IsBound()) + if (!OnInsertVecU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU128")); } return false; } - OnInsertVecByteStruct.Broadcast(Context, Args->S); + OnInsertVecU128.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecByteStructWithArgs(const FReducerEventContext& Context, const FInsertVecByteStructArgs& Args) +bool URemoteReducers::InvokeInsertVecU128WithArgs(const FReducerEventContext& Context, const FInsertVecU128Args& Args) { - if (!OnInsertVecByteStruct.IsBound()) + if (!OnInsertVecU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU128")); } return false; } - OnInsertVecByteStruct.Broadcast(Context, Args.S); + OnInsertVecU128.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecConnectionId(const TArray& A) +void URemoteReducers::InsertVecU16(const TArray& N) { if (!Conn) { @@ -10934,45 +14130,45 @@ void URemoteReducers::InsertVecConnectionId(const TArrayCallReducerTyped(TEXT("insert_vec_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecConnectionId(ReducerArgs)); } + FInsertVecU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecConnectionId(const FReducerEventContext& Context, const UInsertVecConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertVecU16(const FReducerEventContext& Context, const UInsertVecU16Reducer* Args) { - if (!OnInsertVecConnectionId.IsBound()) + if (!OnInsertVecU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU16")); } return false; } - OnInsertVecConnectionId.Broadcast(Context, Args->A); + OnInsertVecU16.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertVecConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertVecU16WithArgs(const FReducerEventContext& Context, const FInsertVecU16Args& Args) { - if (!OnInsertVecConnectionId.IsBound()) + if (!OnInsertVecU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU16")); } return false; } - OnInsertVecConnectionId.Broadcast(Context, Args.A); + OnInsertVecU16.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecEnumWithPayload(const TArray& E) +void URemoteReducers::InsertVecU256(const TArray& N) { if (!Conn) { @@ -10980,45 +14176,45 @@ void URemoteReducers::InsertVecEnumWithPayload(const TArrayCallReducerTyped(TEXT("insert_vec_enum_with_payload"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEnumWithPayload(ReducerArgs)); } + FInsertVecU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecEnumWithPayload(const FReducerEventContext& Context, const UInsertVecEnumWithPayloadReducer* Args) +bool URemoteReducers::InvokeInsertVecU256(const FReducerEventContext& Context, const UInsertVecU256Reducer* Args) { - if (!OnInsertVecEnumWithPayload.IsBound()) + if (!OnInsertVecU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU256")); } return false; } - OnInsertVecEnumWithPayload.Broadcast(Context, Args->E); + OnInsertVecU256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FInsertVecEnumWithPayloadArgs& Args) +bool URemoteReducers::InvokeInsertVecU256WithArgs(const FReducerEventContext& Context, const FInsertVecU256Args& Args) { - if (!OnInsertVecEnumWithPayload.IsBound()) + if (!OnInsertVecU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU256")); } return false; } - OnInsertVecEnumWithPayload.Broadcast(Context, Args.E); + OnInsertVecU256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecEveryPrimitiveStruct(const TArray& S) +void URemoteReducers::InsertVecU32(const TArray& N) { if (!Conn) { @@ -11026,45 +14222,45 @@ void URemoteReducers::InsertVecEveryPrimitiveStruct(const TArrayCallReducerTyped(TEXT("insert_vec_every_primitive_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEveryPrimitiveStruct(ReducerArgs)); } + FInsertVecU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertVecEveryPrimitiveStructReducer* Args) +bool URemoteReducers::InvokeInsertVecU32(const FReducerEventContext& Context, const UInsertVecU32Reducer* Args) { - if (!OnInsertVecEveryPrimitiveStruct.IsBound()) + if (!OnInsertVecU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU32")); } return false; } - OnInsertVecEveryPrimitiveStruct.Broadcast(Context, Args->S); + OnInsertVecU32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertVecEveryPrimitiveStructArgs& Args) +bool URemoteReducers::InvokeInsertVecU32WithArgs(const FReducerEventContext& Context, const FInsertVecU32Args& Args) { - if (!OnInsertVecEveryPrimitiveStruct.IsBound()) + if (!OnInsertVecU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU32")); } return false; } - OnInsertVecEveryPrimitiveStruct.Broadcast(Context, Args.S); + OnInsertVecU32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecEveryVecStruct(const TArray& S) +void URemoteReducers::InsertVecU64(const TArray& N) { if (!Conn) { @@ -11072,45 +14268,45 @@ void URemoteReducers::InsertVecEveryVecStruct(const TArray& return; } - FInsertVecEveryVecStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_every_vec_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEveryVecStruct(ReducerArgs)); } + FInsertVecU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecEveryVecStruct(const FReducerEventContext& Context, const UInsertVecEveryVecStructReducer* Args) +bool URemoteReducers::InvokeInsertVecU64(const FReducerEventContext& Context, const UInsertVecU64Reducer* Args) { - if (!OnInsertVecEveryVecStruct.IsBound()) + if (!OnInsertVecU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU64")); } return false; } - OnInsertVecEveryVecStruct.Broadcast(Context, Args->S); + OnInsertVecU64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecEveryVecStructWithArgs(const FReducerEventContext& Context, const FInsertVecEveryVecStructArgs& Args) +bool URemoteReducers::InvokeInsertVecU64WithArgs(const FReducerEventContext& Context, const FInsertVecU64Args& Args) { - if (!OnInsertVecEveryVecStruct.IsBound()) + if (!OnInsertVecU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU64")); } return false; } - OnInsertVecEveryVecStruct.Broadcast(Context, Args.S); + OnInsertVecU64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecF32(const TArray& F) +void URemoteReducers::InsertVecU8(const TArray& N) { if (!Conn) { @@ -11118,45 +14314,45 @@ void URemoteReducers::InsertVecF32(const TArray& F) return; } - FInsertVecF32Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_f_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecF32(ReducerArgs)); } + FInsertVecU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecF32(const FReducerEventContext& Context, const UInsertVecF32Reducer* Args) +bool URemoteReducers::InvokeInsertVecU8(const FReducerEventContext& Context, const UInsertVecU8Reducer* Args) { - if (!OnInsertVecF32.IsBound()) + if (!OnInsertVecU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU8")); } return false; } - OnInsertVecF32.Broadcast(Context, Args->F); + OnInsertVecU8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecF32WithArgs(const FReducerEventContext& Context, const FInsertVecF32Args& Args) +bool URemoteReducers::InvokeInsertVecU8WithArgs(const FReducerEventContext& Context, const FInsertVecU8Args& Args) { - if (!OnInsertVecF32.IsBound()) + if (!OnInsertVecU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU8")); } return false; } - OnInsertVecF32.Broadcast(Context, Args.F); + OnInsertVecU8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecF64(const TArray& F) +void URemoteReducers::InsertVecUnitStruct(const TArray& S) { if (!Conn) { @@ -11164,45 +14360,45 @@ void URemoteReducers::InsertVecF64(const TArray& F) return; } - FInsertVecF64Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_f_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecF64(ReducerArgs)); } + FInsertVecUnitStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_unit_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecUnitStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecF64(const FReducerEventContext& Context, const UInsertVecF64Reducer* Args) +bool URemoteReducers::InvokeInsertVecUnitStruct(const FReducerEventContext& Context, const UInsertVecUnitStructReducer* Args) { - if (!OnInsertVecF64.IsBound()) + if (!OnInsertVecUnitStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUnitStruct")); } return false; } - OnInsertVecF64.Broadcast(Context, Args->F); + OnInsertVecUnitStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertVecF64WithArgs(const FReducerEventContext& Context, const FInsertVecF64Args& Args) +bool URemoteReducers::InvokeInsertVecUnitStructWithArgs(const FReducerEventContext& Context, const FInsertVecUnitStructArgs& Args) { - if (!OnInsertVecF64.IsBound()) + if (!OnInsertVecUnitStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUnitStruct")); } return false; } - OnInsertVecF64.Broadcast(Context, Args.F); + OnInsertVecUnitStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertVecI128(const TArray& N) +void URemoteReducers::InsertVecUuid(const TArray& U) { if (!Conn) { @@ -11210,45 +14406,45 @@ void URemoteReducers::InsertVecI128(const TArray& N) return; } - FInsertVecI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI128(ReducerArgs)); } + FInsertVecUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI128(const FReducerEventContext& Context, const UInsertVecI128Reducer* Args) +bool URemoteReducers::InvokeInsertVecUuid(const FReducerEventContext& Context, const UInsertVecUuidReducer* Args) { - if (!OnInsertVecI128.IsBound()) + if (!OnInsertVecUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUuid")); } return false; } - OnInsertVecI128.Broadcast(Context, Args->N); + OnInsertVecUuid.Broadcast(Context, Args->U); return true; } -bool URemoteReducers::InvokeInsertVecI128WithArgs(const FReducerEventContext& Context, const FInsertVecI128Args& Args) +bool URemoteReducers::InvokeInsertVecUuidWithArgs(const FReducerEventContext& Context, const FInsertVecUuidArgs& Args) { - if (!OnInsertVecI128.IsBound()) + if (!OnInsertVecUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUuid")); } return false; } - OnInsertVecI128.Broadcast(Context, Args.N); + OnInsertVecUuid.Broadcast(Context, Args.U); return true; } -void URemoteReducers::InsertVecI16(const TArray& N) +void URemoteReducers::NoOpSucceeds() { if (!Conn) { @@ -11256,45 +14452,45 @@ void URemoteReducers::InsertVecI16(const TArray& N) return; } - FInsertVecI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI16(ReducerArgs)); } + FNoOpSucceedsArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("no_op_succeeds"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::NoOpSucceeds(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI16(const FReducerEventContext& Context, const UInsertVecI16Reducer* Args) +bool URemoteReducers::InvokeNoOpSucceeds(const FReducerEventContext& Context, const UNoOpSucceedsReducer* Args) { - if (!OnInsertVecI16.IsBound()) + if (!OnNoOpSucceeds.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for NoOpSucceeds")); } return false; } - OnInsertVecI16.Broadcast(Context, Args->N); + OnNoOpSucceeds.Broadcast(Context); return true; } -bool URemoteReducers::InvokeInsertVecI16WithArgs(const FReducerEventContext& Context, const FInsertVecI16Args& Args) +bool URemoteReducers::InvokeNoOpSucceedsWithArgs(const FReducerEventContext& Context, const FNoOpSucceedsArgs& Args) { - if (!OnInsertVecI16.IsBound()) + if (!OnNoOpSucceeds.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for NoOpSucceeds")); } return false; } - OnInsertVecI16.Broadcast(Context, Args.N); + OnNoOpSucceeds.Broadcast(Context); return true; } -void URemoteReducers::InsertVecI256(const TArray& N) +void URemoteReducers::SortedUuidsInsert() { if (!Conn) { @@ -11302,45 +14498,45 @@ void URemoteReducers::InsertVecI256(const TArray& N) return; } - FInsertVecI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI256(ReducerArgs)); } + FSortedUuidsInsertArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("sorted_uuids_insert"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::SortedUuidsInsert(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI256(const FReducerEventContext& Context, const UInsertVecI256Reducer* Args) +bool URemoteReducers::InvokeSortedUuidsInsert(const FReducerEventContext& Context, const USortedUuidsInsertReducer* Args) { - if (!OnInsertVecI256.IsBound()) + if (!OnSortedUuidsInsert.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for SortedUuidsInsert")); } return false; } - OnInsertVecI256.Broadcast(Context, Args->N); + OnSortedUuidsInsert.Broadcast(Context); return true; } -bool URemoteReducers::InvokeInsertVecI256WithArgs(const FReducerEventContext& Context, const FInsertVecI256Args& Args) +bool URemoteReducers::InvokeSortedUuidsInsertWithArgs(const FReducerEventContext& Context, const FSortedUuidsInsertArgs& Args) { - if (!OnInsertVecI256.IsBound()) + if (!OnSortedUuidsInsert.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for SortedUuidsInsert")); } return false; } - OnInsertVecI256.Broadcast(Context, Args.N); + OnSortedUuidsInsert.Broadcast(Context); return true; } -void URemoteReducers::InsertVecI32(const TArray& N) +void URemoteReducers::UpdateIndexedSimpleEnum(const ESimpleEnumType& A, const ESimpleEnumType& B) { if (!Conn) { @@ -11348,45 +14544,45 @@ void URemoteReducers::InsertVecI32(const TArray& N) return; } - FInsertVecI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI32(ReducerArgs)); } + FUpdateIndexedSimpleEnumArgs ReducerArgs(A, B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_indexed_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateIndexedSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI32(const FReducerEventContext& Context, const UInsertVecI32Reducer* Args) +bool URemoteReducers::InvokeUpdateIndexedSimpleEnum(const FReducerEventContext& Context, const UUpdateIndexedSimpleEnumReducer* Args) { - if (!OnInsertVecI32.IsBound()) + if (!OnUpdateIndexedSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateIndexedSimpleEnum")); } return false; } - OnInsertVecI32.Broadcast(Context, Args->N); + OnUpdateIndexedSimpleEnum.Broadcast(Context, Args->A, Args->B); return true; } -bool URemoteReducers::InvokeInsertVecI32WithArgs(const FReducerEventContext& Context, const FInsertVecI32Args& Args) +bool URemoteReducers::InvokeUpdateIndexedSimpleEnumWithArgs(const FReducerEventContext& Context, const FUpdateIndexedSimpleEnumArgs& Args) { - if (!OnInsertVecI32.IsBound()) + if (!OnUpdateIndexedSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateIndexedSimpleEnum")); } return false; } - OnInsertVecI32.Broadcast(Context, Args.N); + OnUpdateIndexedSimpleEnum.Broadcast(Context, Args.A, Args.B); return true; } -void URemoteReducers::InsertVecI64(const TArray& N) +void URemoteReducers::UpdatePkBool(const bool B, const int32 Data) { if (!Conn) { @@ -11394,45 +14590,45 @@ void URemoteReducers::InsertVecI64(const TArray& N) return; } - FInsertVecI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI64(ReducerArgs)); } + FUpdatePkBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI64(const FReducerEventContext& Context, const UInsertVecI64Reducer* Args) +bool URemoteReducers::InvokeUpdatePkBool(const FReducerEventContext& Context, const UUpdatePkBoolReducer* Args) { - if (!OnInsertVecI64.IsBound()) + if (!OnUpdatePkBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkBool")); } return false; } - OnInsertVecI64.Broadcast(Context, Args->N); + OnUpdatePkBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecI64WithArgs(const FReducerEventContext& Context, const FInsertVecI64Args& Args) +bool URemoteReducers::InvokeUpdatePkBoolWithArgs(const FReducerEventContext& Context, const FUpdatePkBoolArgs& Args) { - if (!OnInsertVecI64.IsBound()) + if (!OnUpdatePkBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkBool")); } return false; } - OnInsertVecI64.Broadcast(Context, Args.N); + OnUpdatePkBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::InsertVecI8(const TArray& N) +void URemoteReducers::UpdatePkConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) { if (!Conn) { @@ -11440,45 +14636,45 @@ void URemoteReducers::InsertVecI8(const TArray& N) return; } - FInsertVecI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI8(ReducerArgs)); } + FUpdatePkConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI8(const FReducerEventContext& Context, const UInsertVecI8Reducer* Args) +bool URemoteReducers::InvokeUpdatePkConnectionId(const FReducerEventContext& Context, const UUpdatePkConnectionIdReducer* Args) { - if (!OnInsertVecI8.IsBound()) + if (!OnUpdatePkConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkConnectionId")); } return false; } - OnInsertVecI8.Broadcast(Context, Args->N); + OnUpdatePkConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecI8WithArgs(const FReducerEventContext& Context, const FInsertVecI8Args& Args) +bool URemoteReducers::InvokeUpdatePkConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdatePkConnectionIdArgs& Args) { - if (!OnInsertVecI8.IsBound()) + if (!OnUpdatePkConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkConnectionId")); } return false; } - OnInsertVecI8.Broadcast(Context, Args.N); + OnUpdatePkConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertVecIdentity(const TArray& I) +void URemoteReducers::UpdatePkI128(const FSpacetimeDBInt128& N, const int32 Data) { if (!Conn) { @@ -11486,45 +14682,45 @@ void URemoteReducers::InsertVecIdentity(const TArray& I) return; } - FInsertVecIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecIdentity(ReducerArgs)); } + FUpdatePkI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecIdentity(const FReducerEventContext& Context, const UInsertVecIdentityReducer* Args) +bool URemoteReducers::InvokeUpdatePkI128(const FReducerEventContext& Context, const UUpdatePkI128Reducer* Args) { - if (!OnInsertVecIdentity.IsBound()) + if (!OnUpdatePkI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI128")); } return false; } - OnInsertVecIdentity.Broadcast(Context, Args->I); + OnUpdatePkI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecIdentityWithArgs(const FReducerEventContext& Context, const FInsertVecIdentityArgs& Args) +bool URemoteReducers::InvokeUpdatePkI128WithArgs(const FReducerEventContext& Context, const FUpdatePkI128Args& Args) { - if (!OnInsertVecIdentity.IsBound()) + if (!OnUpdatePkI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI128")); } return false; } - OnInsertVecIdentity.Broadcast(Context, Args.I); + OnUpdatePkI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecSimpleEnum(const TArray& E) +void URemoteReducers::UpdatePkI16(const int16 N, const int32 Data) { if (!Conn) { @@ -11532,45 +14728,45 @@ void URemoteReducers::InsertVecSimpleEnum(const TArray& E) return; } - FInsertVecSimpleEnumArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecSimpleEnum(ReducerArgs)); } + FUpdatePkI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecSimpleEnum(const FReducerEventContext& Context, const UInsertVecSimpleEnumReducer* Args) +bool URemoteReducers::InvokeUpdatePkI16(const FReducerEventContext& Context, const UUpdatePkI16Reducer* Args) { - if (!OnInsertVecSimpleEnum.IsBound()) + if (!OnUpdatePkI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI16")); } return false; } - OnInsertVecSimpleEnum.Broadcast(Context, Args->E); + OnUpdatePkI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertVecSimpleEnumArgs& Args) +bool URemoteReducers::InvokeUpdatePkI16WithArgs(const FReducerEventContext& Context, const FUpdatePkI16Args& Args) { - if (!OnInsertVecSimpleEnum.IsBound()) + if (!OnUpdatePkI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI16")); } return false; } - OnInsertVecSimpleEnum.Broadcast(Context, Args.E); + OnUpdatePkI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecString(const TArray& S) +void URemoteReducers::UpdatePkI256(const FSpacetimeDBInt256& N, const int32 Data) { if (!Conn) { @@ -11578,45 +14774,45 @@ void URemoteReducers::InsertVecString(const TArray& S) return; } - FInsertVecStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecString(ReducerArgs)); } + FUpdatePkI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecString(const FReducerEventContext& Context, const UInsertVecStringReducer* Args) +bool URemoteReducers::InvokeUpdatePkI256(const FReducerEventContext& Context, const UUpdatePkI256Reducer* Args) { - if (!OnInsertVecString.IsBound()) + if (!OnUpdatePkI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI256")); } return false; } - OnInsertVecString.Broadcast(Context, Args->S); + OnUpdatePkI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecStringWithArgs(const FReducerEventContext& Context, const FInsertVecStringArgs& Args) +bool URemoteReducers::InvokeUpdatePkI256WithArgs(const FReducerEventContext& Context, const FUpdatePkI256Args& Args) { - if (!OnInsertVecString.IsBound()) + if (!OnUpdatePkI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI256")); } return false; } - OnInsertVecString.Broadcast(Context, Args.S); + OnUpdatePkI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecTimestamp(const TArray& T) +void URemoteReducers::UpdatePkI32(const int32 N, const int32 Data) { if (!Conn) { @@ -11624,45 +14820,45 @@ void URemoteReducers::InsertVecTimestamp(const TArray& T) return; } - FInsertVecTimestampArgs ReducerArgs(T); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_timestamp"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecTimestamp(ReducerArgs)); } + FUpdatePkI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecTimestamp(const FReducerEventContext& Context, const UInsertVecTimestampReducer* Args) +bool URemoteReducers::InvokeUpdatePkI32(const FReducerEventContext& Context, const UUpdatePkI32Reducer* Args) { - if (!OnInsertVecTimestamp.IsBound()) + if (!OnUpdatePkI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI32")); } return false; } - OnInsertVecTimestamp.Broadcast(Context, Args->T); + OnUpdatePkI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecTimestampWithArgs(const FReducerEventContext& Context, const FInsertVecTimestampArgs& Args) +bool URemoteReducers::InvokeUpdatePkI32WithArgs(const FReducerEventContext& Context, const FUpdatePkI32Args& Args) { - if (!OnInsertVecTimestamp.IsBound()) + if (!OnUpdatePkI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI32")); } return false; } - OnInsertVecTimestamp.Broadcast(Context, Args.T); + OnUpdatePkI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecU128(const TArray& N) +void URemoteReducers::UpdatePkI64(const int64 N, const int32 Data) { if (!Conn) { @@ -11670,45 +14866,45 @@ void URemoteReducers::InsertVecU128(const TArray& N) return; } - FInsertVecU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU128(ReducerArgs)); } + FUpdatePkI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU128(const FReducerEventContext& Context, const UInsertVecU128Reducer* Args) +bool URemoteReducers::InvokeUpdatePkI64(const FReducerEventContext& Context, const UUpdatePkI64Reducer* Args) { - if (!OnInsertVecU128.IsBound()) + if (!OnUpdatePkI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI64")); } return false; } - OnInsertVecU128.Broadcast(Context, Args->N); + OnUpdatePkI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU128WithArgs(const FReducerEventContext& Context, const FInsertVecU128Args& Args) +bool URemoteReducers::InvokeUpdatePkI64WithArgs(const FReducerEventContext& Context, const FUpdatePkI64Args& Args) { - if (!OnInsertVecU128.IsBound()) + if (!OnUpdatePkI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI64")); } return false; } - OnInsertVecU128.Broadcast(Context, Args.N); + OnUpdatePkI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecU16(const TArray& N) +void URemoteReducers::UpdatePkI8(const int8 N, const int32 Data) { if (!Conn) { @@ -11716,45 +14912,45 @@ void URemoteReducers::InsertVecU16(const TArray& N) return; } - FInsertVecU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU16(ReducerArgs)); } + FUpdatePkI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU16(const FReducerEventContext& Context, const UInsertVecU16Reducer* Args) +bool URemoteReducers::InvokeUpdatePkI8(const FReducerEventContext& Context, const UUpdatePkI8Reducer* Args) { - if (!OnInsertVecU16.IsBound()) + if (!OnUpdatePkI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI8")); } return false; } - OnInsertVecU16.Broadcast(Context, Args->N); + OnUpdatePkI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU16WithArgs(const FReducerEventContext& Context, const FInsertVecU16Args& Args) +bool URemoteReducers::InvokeUpdatePkI8WithArgs(const FReducerEventContext& Context, const FUpdatePkI8Args& Args) { - if (!OnInsertVecU16.IsBound()) + if (!OnUpdatePkI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI8")); } return false; } - OnInsertVecU16.Broadcast(Context, Args.N); + OnUpdatePkI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecU256(const TArray& N) +void URemoteReducers::UpdatePkIdentity(const FSpacetimeDBIdentity& I, const int32 Data) { if (!Conn) { @@ -11762,45 +14958,45 @@ void URemoteReducers::InsertVecU256(const TArray& N) return; } - FInsertVecU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU256(ReducerArgs)); } + FUpdatePkIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU256(const FReducerEventContext& Context, const UInsertVecU256Reducer* Args) +bool URemoteReducers::InvokeUpdatePkIdentity(const FReducerEventContext& Context, const UUpdatePkIdentityReducer* Args) { - if (!OnInsertVecU256.IsBound()) + if (!OnUpdatePkIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkIdentity")); } return false; } - OnInsertVecU256.Broadcast(Context, Args->N); + OnUpdatePkIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU256WithArgs(const FReducerEventContext& Context, const FInsertVecU256Args& Args) +bool URemoteReducers::InvokeUpdatePkIdentityWithArgs(const FReducerEventContext& Context, const FUpdatePkIdentityArgs& Args) { - if (!OnInsertVecU256.IsBound()) + if (!OnUpdatePkIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkIdentity")); } return false; } - OnInsertVecU256.Broadcast(Context, Args.N); + OnUpdatePkIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::InsertVecU32(const TArray& N) +void URemoteReducers::UpdatePkSimpleEnum(const ESimpleEnumType& A, const int32 Data) { if (!Conn) { @@ -11808,45 +15004,45 @@ void URemoteReducers::InsertVecU32(const TArray& N) return; } - FInsertVecU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU32(ReducerArgs)); } + FUpdatePkSimpleEnumArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU32(const FReducerEventContext& Context, const UInsertVecU32Reducer* Args) +bool URemoteReducers::InvokeUpdatePkSimpleEnum(const FReducerEventContext& Context, const UUpdatePkSimpleEnumReducer* Args) { - if (!OnInsertVecU32.IsBound()) + if (!OnUpdatePkSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkSimpleEnum")); } return false; } - OnInsertVecU32.Broadcast(Context, Args->N); + OnUpdatePkSimpleEnum.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU32WithArgs(const FReducerEventContext& Context, const FInsertVecU32Args& Args) +bool URemoteReducers::InvokeUpdatePkSimpleEnumWithArgs(const FReducerEventContext& Context, const FUpdatePkSimpleEnumArgs& Args) { - if (!OnInsertVecU32.IsBound()) + if (!OnUpdatePkSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkSimpleEnum")); } return false; } - OnInsertVecU32.Broadcast(Context, Args.N); + OnUpdatePkSimpleEnum.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertVecU64(const TArray& N) +void URemoteReducers::UpdatePkString(const FString& S, const int32 Data) { if (!Conn) { @@ -11854,45 +15050,45 @@ void URemoteReducers::InsertVecU64(const TArray& N) return; } - FInsertVecU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU64(ReducerArgs)); } + FUpdatePkStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU64(const FReducerEventContext& Context, const UInsertVecU64Reducer* Args) +bool URemoteReducers::InvokeUpdatePkString(const FReducerEventContext& Context, const UUpdatePkStringReducer* Args) { - if (!OnInsertVecU64.IsBound()) + if (!OnUpdatePkString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkString")); } return false; } - OnInsertVecU64.Broadcast(Context, Args->N); + OnUpdatePkString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU64WithArgs(const FReducerEventContext& Context, const FInsertVecU64Args& Args) +bool URemoteReducers::InvokeUpdatePkStringWithArgs(const FReducerEventContext& Context, const FUpdatePkStringArgs& Args) { - if (!OnInsertVecU64.IsBound()) + if (!OnUpdatePkString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkString")); } return false; } - OnInsertVecU64.Broadcast(Context, Args.N); + OnUpdatePkString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::InsertVecU8(const TArray& N) +void URemoteReducers::UpdatePkU128(const FSpacetimeDBUInt128& N, const int32 Data) { if (!Conn) { @@ -11900,45 +15096,45 @@ void URemoteReducers::InsertVecU8(const TArray& N) return; } - FInsertVecU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU8(ReducerArgs)); } + FUpdatePkU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU8(const FReducerEventContext& Context, const UInsertVecU8Reducer* Args) +bool URemoteReducers::InvokeUpdatePkU128(const FReducerEventContext& Context, const UUpdatePkU128Reducer* Args) { - if (!OnInsertVecU8.IsBound()) + if (!OnUpdatePkU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU128")); } return false; } - OnInsertVecU8.Broadcast(Context, Args->N); + OnUpdatePkU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU8WithArgs(const FReducerEventContext& Context, const FInsertVecU8Args& Args) +bool URemoteReducers::InvokeUpdatePkU128WithArgs(const FReducerEventContext& Context, const FUpdatePkU128Args& Args) { - if (!OnInsertVecU8.IsBound()) + if (!OnUpdatePkU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU128")); } return false; } - OnInsertVecU8.Broadcast(Context, Args.N); + OnUpdatePkU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecUnitStruct(const TArray& S) +void URemoteReducers::UpdatePkU16(const uint16 N, const int32 Data) { if (!Conn) { @@ -11946,45 +15142,45 @@ void URemoteReducers::InsertVecUnitStruct(const TArray& S) return; } - FInsertVecUnitStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_unit_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecUnitStruct(ReducerArgs)); } + FUpdatePkU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecUnitStruct(const FReducerEventContext& Context, const UInsertVecUnitStructReducer* Args) +bool URemoteReducers::InvokeUpdatePkU16(const FReducerEventContext& Context, const UUpdatePkU16Reducer* Args) { - if (!OnInsertVecUnitStruct.IsBound()) + if (!OnUpdatePkU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU16")); } return false; } - OnInsertVecUnitStruct.Broadcast(Context, Args->S); + OnUpdatePkU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecUnitStructWithArgs(const FReducerEventContext& Context, const FInsertVecUnitStructArgs& Args) +bool URemoteReducers::InvokeUpdatePkU16WithArgs(const FReducerEventContext& Context, const FUpdatePkU16Args& Args) { - if (!OnInsertVecUnitStruct.IsBound()) + if (!OnUpdatePkU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU16")); } return false; } - OnInsertVecUnitStruct.Broadcast(Context, Args.S); + OnUpdatePkU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecUuid(const TArray& U) +void URemoteReducers::UpdatePkU256(const FSpacetimeDBUInt256& N, const int32 Data) { if (!Conn) { @@ -11992,45 +15188,45 @@ void URemoteReducers::InsertVecUuid(const TArray& U) return; } - FInsertVecUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecUuid(ReducerArgs)); } + FUpdatePkU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecUuid(const FReducerEventContext& Context, const UInsertVecUuidReducer* Args) +bool URemoteReducers::InvokeUpdatePkU256(const FReducerEventContext& Context, const UUpdatePkU256Reducer* Args) { - if (!OnInsertVecUuid.IsBound()) + if (!OnUpdatePkU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU256")); } return false; } - OnInsertVecUuid.Broadcast(Context, Args->U); + OnUpdatePkU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecUuidWithArgs(const FReducerEventContext& Context, const FInsertVecUuidArgs& Args) +bool URemoteReducers::InvokeUpdatePkU256WithArgs(const FReducerEventContext& Context, const FUpdatePkU256Args& Args) { - if (!OnInsertVecUuid.IsBound()) + if (!OnUpdatePkU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU256")); } return false; } - OnInsertVecUuid.Broadcast(Context, Args.U); + OnUpdatePkU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::NoOpSucceeds() +void URemoteReducers::UpdatePkU32(const uint32 N, const int32 Data) { if (!Conn) { @@ -12038,45 +15234,45 @@ void URemoteReducers::NoOpSucceeds() return; } - FNoOpSucceedsArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("no_op_succeeds"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::NoOpSucceeds(ReducerArgs)); } + FUpdatePkU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU32(ReducerArgs)); } } -bool URemoteReducers::InvokeNoOpSucceeds(const FReducerEventContext& Context, const UNoOpSucceedsReducer* Args) +bool URemoteReducers::InvokeUpdatePkU32(const FReducerEventContext& Context, const UUpdatePkU32Reducer* Args) { - if (!OnNoOpSucceeds.IsBound()) + if (!OnUpdatePkU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for NoOpSucceeds")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32")); } return false; } - OnNoOpSucceeds.Broadcast(Context); + OnUpdatePkU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeNoOpSucceedsWithArgs(const FReducerEventContext& Context, const FNoOpSucceedsArgs& Args) +bool URemoteReducers::InvokeUpdatePkU32WithArgs(const FReducerEventContext& Context, const FUpdatePkU32Args& Args) { - if (!OnNoOpSucceeds.IsBound()) + if (!OnUpdatePkU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for NoOpSucceeds")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32")); } return false; } - OnNoOpSucceeds.Broadcast(Context); + OnUpdatePkU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::SortedUuidsInsert() +void URemoteReducers::UpdatePkU32Two(const uint32 N, const int32 Data) { if (!Conn) { @@ -12084,45 +15280,45 @@ void URemoteReducers::SortedUuidsInsert() return; } - FSortedUuidsInsertArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("sorted_uuids_insert"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::SortedUuidsInsert(ReducerArgs)); } + FUpdatePkU32TwoArgs ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_32_two"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU32Two(ReducerArgs)); } } -bool URemoteReducers::InvokeSortedUuidsInsert(const FReducerEventContext& Context, const USortedUuidsInsertReducer* Args) +bool URemoteReducers::InvokeUpdatePkU32Two(const FReducerEventContext& Context, const UUpdatePkU32TwoReducer* Args) { - if (!OnSortedUuidsInsert.IsBound()) + if (!OnUpdatePkU32Two.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for SortedUuidsInsert")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32Two")); } return false; } - OnSortedUuidsInsert.Broadcast(Context); + OnUpdatePkU32Two.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeSortedUuidsInsertWithArgs(const FReducerEventContext& Context, const FSortedUuidsInsertArgs& Args) +bool URemoteReducers::InvokeUpdatePkU32TwoWithArgs(const FReducerEventContext& Context, const FUpdatePkU32TwoArgs& Args) { - if (!OnSortedUuidsInsert.IsBound()) + if (!OnUpdatePkU32Two.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for SortedUuidsInsert")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32Two")); } return false; } - OnSortedUuidsInsert.Broadcast(Context); + OnUpdatePkU32Two.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateIndexedSimpleEnum(const ESimpleEnumType& A, const ESimpleEnumType& B) +void URemoteReducers::UpdatePkU64(const uint64 N, const int32 Data) { if (!Conn) { @@ -12130,45 +15326,45 @@ void URemoteReducers::UpdateIndexedSimpleEnum(const ESimpleEnumType& A, const ES return; } - FUpdateIndexedSimpleEnumArgs ReducerArgs(A, B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_indexed_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateIndexedSimpleEnum(ReducerArgs)); } + FUpdatePkU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU64(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateIndexedSimpleEnum(const FReducerEventContext& Context, const UUpdateIndexedSimpleEnumReducer* Args) +bool URemoteReducers::InvokeUpdatePkU64(const FReducerEventContext& Context, const UUpdatePkU64Reducer* Args) { - if (!OnUpdateIndexedSimpleEnum.IsBound()) + if (!OnUpdatePkU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateIndexedSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU64")); } return false; } - OnUpdateIndexedSimpleEnum.Broadcast(Context, Args->A, Args->B); + OnUpdatePkU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateIndexedSimpleEnumWithArgs(const FReducerEventContext& Context, const FUpdateIndexedSimpleEnumArgs& Args) +bool URemoteReducers::InvokeUpdatePkU64WithArgs(const FReducerEventContext& Context, const FUpdatePkU64Args& Args) { - if (!OnUpdateIndexedSimpleEnum.IsBound()) + if (!OnUpdatePkU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateIndexedSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU64")); } return false; } - OnUpdateIndexedSimpleEnum.Broadcast(Context, Args.A, Args.B); + OnUpdatePkU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkBool(const bool B, const int32 Data) +void URemoteReducers::UpdatePkU8(const uint8 N, const int32 Data) { if (!Conn) { @@ -12176,45 +15372,45 @@ void URemoteReducers::UpdatePkBool(const bool B, const int32 Data) return; } - FUpdatePkBoolArgs ReducerArgs(B, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkBool(ReducerArgs)); } + FUpdatePkU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU8(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkBool(const FReducerEventContext& Context, const UUpdatePkBoolReducer* Args) +bool URemoteReducers::InvokeUpdatePkU8(const FReducerEventContext& Context, const UUpdatePkU8Reducer* Args) { - if (!OnUpdatePkBool.IsBound()) + if (!OnUpdatePkU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU8")); } return false; } - OnUpdatePkBool.Broadcast(Context, Args->B, Args->Data); + OnUpdatePkU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkBoolWithArgs(const FReducerEventContext& Context, const FUpdatePkBoolArgs& Args) +bool URemoteReducers::InvokeUpdatePkU8WithArgs(const FReducerEventContext& Context, const FUpdatePkU8Args& Args) { - if (!OnUpdatePkBool.IsBound()) + if (!OnUpdatePkU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU8")); } return false; } - OnUpdatePkBool.Broadcast(Context, Args.B, Args.Data); + OnUpdatePkU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) +void URemoteReducers::UpdatePkUuid(const FSpacetimeDBUuid& U, const int32 Data) { if (!Conn) { @@ -12222,45 +15418,45 @@ void URemoteReducers::UpdatePkConnectionId(const FSpacetimeDBConnectionId& A, co return; } - FUpdatePkConnectionIdArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkConnectionId(ReducerArgs)); } + FUpdatePkUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkConnectionId(const FReducerEventContext& Context, const UUpdatePkConnectionIdReducer* Args) +bool URemoteReducers::InvokeUpdatePkUuid(const FReducerEventContext& Context, const UUpdatePkUuidReducer* Args) { - if (!OnUpdatePkConnectionId.IsBound()) + if (!OnUpdatePkUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkUuid")); } return false; } - OnUpdatePkConnectionId.Broadcast(Context, Args->A, Args->Data); + OnUpdatePkUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdatePkConnectionIdArgs& Args) +bool URemoteReducers::InvokeUpdatePkUuidWithArgs(const FReducerEventContext& Context, const FUpdatePkUuidArgs& Args) { - if (!OnUpdatePkConnectionId.IsBound()) + if (!OnUpdatePkUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkUuid")); } return false; } - OnUpdatePkConnectionId.Broadcast(Context, Args.A, Args.Data); + OnUpdatePkUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::UpdatePkI128(const FSpacetimeDBInt128& N, const int32 Data) +void URemoteReducers::UpdateUniqueBool(const bool B, const int32 Data) { if (!Conn) { @@ -12268,45 +15464,45 @@ void URemoteReducers::UpdatePkI128(const FSpacetimeDBInt128& N, const int32 Data return; } - FUpdatePkI128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI128(ReducerArgs)); } + FUpdateUniqueBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueBool(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI128(const FReducerEventContext& Context, const UUpdatePkI128Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueBool(const FReducerEventContext& Context, const UUpdateUniqueBoolReducer* Args) { - if (!OnUpdatePkI128.IsBound()) + if (!OnUpdateUniqueBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueBool")); } return false; } - OnUpdatePkI128.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI128WithArgs(const FReducerEventContext& Context, const FUpdatePkI128Args& Args) +bool URemoteReducers::InvokeUpdateUniqueBoolWithArgs(const FReducerEventContext& Context, const FUpdateUniqueBoolArgs& Args) { - if (!OnUpdatePkI128.IsBound()) + if (!OnUpdateUniqueBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueBool")); } return false; } - OnUpdatePkI128.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::UpdatePkI16(const int16 N, const int32 Data) +void URemoteReducers::UpdateUniqueConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) { if (!Conn) { @@ -12314,45 +15510,45 @@ void URemoteReducers::UpdatePkI16(const int16 N, const int32 Data) return; } - FUpdatePkI16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI16(ReducerArgs)); } + FUpdateUniqueConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI16(const FReducerEventContext& Context, const UUpdatePkI16Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueConnectionId(const FReducerEventContext& Context, const UUpdateUniqueConnectionIdReducer* Args) { - if (!OnUpdatePkI16.IsBound()) + if (!OnUpdateUniqueConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueConnectionId")); } return false; } - OnUpdatePkI16.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI16WithArgs(const FReducerEventContext& Context, const FUpdatePkI16Args& Args) +bool URemoteReducers::InvokeUpdateUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdateUniqueConnectionIdArgs& Args) { - if (!OnUpdatePkI16.IsBound()) + if (!OnUpdateUniqueConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueConnectionId")); } return false; } - OnUpdatePkI16.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::UpdatePkI256(const FSpacetimeDBInt256& N, const int32 Data) +void URemoteReducers::UpdateUniqueI128(const FSpacetimeDBInt128& N, const int32 Data) { if (!Conn) { @@ -12360,45 +15556,45 @@ void URemoteReducers::UpdatePkI256(const FSpacetimeDBInt256& N, const int32 Data return; } - FUpdatePkI256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI256(ReducerArgs)); } + FUpdateUniqueI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI128(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI256(const FReducerEventContext& Context, const UUpdatePkI256Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI128(const FReducerEventContext& Context, const UUpdateUniqueI128Reducer* Args) { - if (!OnUpdatePkI256.IsBound()) + if (!OnUpdateUniqueI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI128")); } return false; } - OnUpdatePkI256.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI256WithArgs(const FReducerEventContext& Context, const FUpdatePkI256Args& Args) +bool URemoteReducers::InvokeUpdateUniqueI128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI128Args& Args) { - if (!OnUpdatePkI256.IsBound()) + if (!OnUpdateUniqueI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI128")); } return false; } - OnUpdatePkI256.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkI32(const int32 N, const int32 Data) +void URemoteReducers::UpdateUniqueI16(const int16 N, const int32 Data) { if (!Conn) { @@ -12406,45 +15602,45 @@ void URemoteReducers::UpdatePkI32(const int32 N, const int32 Data) return; } - FUpdatePkI32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI32(ReducerArgs)); } + FUpdateUniqueI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI16(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI32(const FReducerEventContext& Context, const UUpdatePkI32Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI16(const FReducerEventContext& Context, const UUpdateUniqueI16Reducer* Args) { - if (!OnUpdatePkI32.IsBound()) + if (!OnUpdateUniqueI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI16")); } return false; } - OnUpdatePkI32.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI32WithArgs(const FReducerEventContext& Context, const FUpdatePkI32Args& Args) +bool URemoteReducers::InvokeUpdateUniqueI16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI16Args& Args) { - if (!OnUpdatePkI32.IsBound()) + if (!OnUpdateUniqueI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI16")); } return false; } - OnUpdatePkI32.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkI64(const int64 N, const int32 Data) +void URemoteReducers::UpdateUniqueI256(const FSpacetimeDBInt256& N, const int32 Data) { if (!Conn) { @@ -12452,45 +15648,45 @@ void URemoteReducers::UpdatePkI64(const int64 N, const int32 Data) return; } - FUpdatePkI64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI64(ReducerArgs)); } + FUpdateUniqueI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI256(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI64(const FReducerEventContext& Context, const UUpdatePkI64Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI256(const FReducerEventContext& Context, const UUpdateUniqueI256Reducer* Args) { - if (!OnUpdatePkI64.IsBound()) + if (!OnUpdateUniqueI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI256")); } return false; } - OnUpdatePkI64.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI64WithArgs(const FReducerEventContext& Context, const FUpdatePkI64Args& Args) +bool URemoteReducers::InvokeUpdateUniqueI256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI256Args& Args) { - if (!OnUpdatePkI64.IsBound()) + if (!OnUpdateUniqueI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI256")); } return false; } - OnUpdatePkI64.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkI8(const int8 N, const int32 Data) +void URemoteReducers::UpdateUniqueI32(const int32 N, const int32 Data) { if (!Conn) { @@ -12498,45 +15694,45 @@ void URemoteReducers::UpdatePkI8(const int8 N, const int32 Data) return; } - FUpdatePkI8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI8(ReducerArgs)); } + FUpdateUniqueI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI32(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI8(const FReducerEventContext& Context, const UUpdatePkI8Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI32(const FReducerEventContext& Context, const UUpdateUniqueI32Reducer* Args) { - if (!OnUpdatePkI8.IsBound()) + if (!OnUpdateUniqueI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI32")); } return false; } - OnUpdatePkI8.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI8WithArgs(const FReducerEventContext& Context, const FUpdatePkI8Args& Args) +bool URemoteReducers::InvokeUpdateUniqueI32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI32Args& Args) { - if (!OnUpdatePkI8.IsBound()) + if (!OnUpdateUniqueI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI32")); } return false; } - OnUpdatePkI8.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkIdentity(const FSpacetimeDBIdentity& I, const int32 Data) +void URemoteReducers::UpdateUniqueI64(const int64 N, const int32 Data) { if (!Conn) { @@ -12544,45 +15740,45 @@ void URemoteReducers::UpdatePkIdentity(const FSpacetimeDBIdentity& I, const int3 return; } - FUpdatePkIdentityArgs ReducerArgs(I, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkIdentity(ReducerArgs)); } + FUpdateUniqueI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI64(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkIdentity(const FReducerEventContext& Context, const UUpdatePkIdentityReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI64(const FReducerEventContext& Context, const UUpdateUniqueI64Reducer* Args) { - if (!OnUpdatePkIdentity.IsBound()) + if (!OnUpdateUniqueI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI64")); } return false; } - OnUpdatePkIdentity.Broadcast(Context, Args->I, Args->Data); + OnUpdateUniqueI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkIdentityWithArgs(const FReducerEventContext& Context, const FUpdatePkIdentityArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueI64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI64Args& Args) { - if (!OnUpdatePkIdentity.IsBound()) + if (!OnUpdateUniqueI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI64")); } return false; } - OnUpdatePkIdentity.Broadcast(Context, Args.I, Args.Data); + OnUpdateUniqueI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkSimpleEnum(const ESimpleEnumType& A, const int32 Data) +void URemoteReducers::UpdateUniqueI8(const int8 N, const int32 Data) { if (!Conn) { @@ -12590,45 +15786,45 @@ void URemoteReducers::UpdatePkSimpleEnum(const ESimpleEnumType& A, const int32 D return; } - FUpdatePkSimpleEnumArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkSimpleEnum(ReducerArgs)); } + FUpdateUniqueI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI8(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkSimpleEnum(const FReducerEventContext& Context, const UUpdatePkSimpleEnumReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI8(const FReducerEventContext& Context, const UUpdateUniqueI8Reducer* Args) { - if (!OnUpdatePkSimpleEnum.IsBound()) + if (!OnUpdateUniqueI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI8")); } return false; } - OnUpdatePkSimpleEnum.Broadcast(Context, Args->A, Args->Data); + OnUpdateUniqueI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkSimpleEnumWithArgs(const FReducerEventContext& Context, const FUpdatePkSimpleEnumArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueI8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI8Args& Args) { - if (!OnUpdatePkSimpleEnum.IsBound()) + if (!OnUpdateUniqueI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI8")); } return false; } - OnUpdatePkSimpleEnum.Broadcast(Context, Args.A, Args.Data); + OnUpdateUniqueI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkString(const FString& S, const int32 Data) +void URemoteReducers::UpdateUniqueIdentity(const FSpacetimeDBIdentity& I, const int32 Data) { if (!Conn) { @@ -12636,45 +15832,45 @@ void URemoteReducers::UpdatePkString(const FString& S, const int32 Data) return; } - FUpdatePkStringArgs ReducerArgs(S, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkString(ReducerArgs)); } + FUpdateUniqueIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkString(const FReducerEventContext& Context, const UUpdatePkStringReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueIdentity(const FReducerEventContext& Context, const UUpdateUniqueIdentityReducer* Args) { - if (!OnUpdatePkString.IsBound()) + if (!OnUpdateUniqueIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueIdentity")); } return false; } - OnUpdatePkString.Broadcast(Context, Args->S, Args->Data); + OnUpdateUniqueIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkStringWithArgs(const FReducerEventContext& Context, const FUpdatePkStringArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueIdentityArgs& Args) { - if (!OnUpdatePkString.IsBound()) + if (!OnUpdateUniqueIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueIdentity")); } return false; } - OnUpdatePkString.Broadcast(Context, Args.S, Args.Data); + OnUpdateUniqueIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::UpdatePkU128(const FSpacetimeDBUInt128& N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data) { if (!Conn) { @@ -12682,45 +15878,45 @@ void URemoteReducers::UpdatePkU128(const FSpacetimeDBUInt128& N, const int32 Dat return; } - FUpdatePkU128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU128(ReducerArgs)); } + FUpdateUniqueOptionBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionBool(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU128(const FReducerEventContext& Context, const UUpdatePkU128Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionBool(const FReducerEventContext& Context, const UUpdateUniqueOptionBoolReducer* Args) { - if (!OnUpdatePkU128.IsBound()) + if (!OnUpdateUniqueOptionBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionBool")); } return false; } - OnUpdatePkU128.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU128WithArgs(const FReducerEventContext& Context, const FUpdatePkU128Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionBoolArgs& Args) { - if (!OnUpdatePkU128.IsBound()) + if (!OnUpdateUniqueOptionBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionBool")); } return false; } - OnUpdatePkU128.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::UpdatePkU16(const uint16 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data) { if (!Conn) { @@ -12728,45 +15924,45 @@ void URemoteReducers::UpdatePkU16(const uint16 N, const int32 Data) return; } - FUpdatePkU16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU16(ReducerArgs)); } + FUpdateUniqueOptionConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU16(const FReducerEventContext& Context, const UUpdatePkU16Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionConnectionId(const FReducerEventContext& Context, const UUpdateUniqueOptionConnectionIdReducer* Args) { - if (!OnUpdatePkU16.IsBound()) + if (!OnUpdateUniqueOptionConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionConnectionId")); } return false; } - OnUpdatePkU16.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU16WithArgs(const FReducerEventContext& Context, const FUpdatePkU16Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionConnectionIdArgs& Args) { - if (!OnUpdatePkU16.IsBound()) + if (!OnUpdateUniqueOptionConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionConnectionId")); } return false; } - OnUpdatePkU16.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::UpdatePkU256(const FSpacetimeDBUInt256& N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data) { if (!Conn) { @@ -12774,45 +15970,45 @@ void URemoteReducers::UpdatePkU256(const FSpacetimeDBUInt256& N, const int32 Dat return; } - FUpdatePkU256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU256(ReducerArgs)); } + FUpdateUniqueOptionI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI128(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU256(const FReducerEventContext& Context, const UUpdatePkU256Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI128(const FReducerEventContext& Context, const UUpdateUniqueOptionI128Reducer* Args) { - if (!OnUpdatePkU256.IsBound()) + if (!OnUpdateUniqueOptionI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI128")); } return false; } - OnUpdatePkU256.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU256WithArgs(const FReducerEventContext& Context, const FUpdatePkU256Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI128Args& Args) { - if (!OnUpdatePkU256.IsBound()) + if (!OnUpdateUniqueOptionI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI128")); } return false; } - OnUpdatePkU256.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkU32(const uint32 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data) { if (!Conn) { @@ -12820,45 +16016,45 @@ void URemoteReducers::UpdatePkU32(const uint32 N, const int32 Data) return; } - FUpdatePkU32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU32(ReducerArgs)); } + FUpdateUniqueOptionI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI16(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU32(const FReducerEventContext& Context, const UUpdatePkU32Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI16(const FReducerEventContext& Context, const UUpdateUniqueOptionI16Reducer* Args) { - if (!OnUpdatePkU32.IsBound()) + if (!OnUpdateUniqueOptionI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI16")); } return false; } - OnUpdatePkU32.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU32WithArgs(const FReducerEventContext& Context, const FUpdatePkU32Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI16Args& Args) { - if (!OnUpdatePkU32.IsBound()) + if (!OnUpdateUniqueOptionI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI16")); } return false; } - OnUpdatePkU32.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkU32Two(const uint32 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data) { if (!Conn) { @@ -12866,45 +16062,45 @@ void URemoteReducers::UpdatePkU32Two(const uint32 N, const int32 Data) return; } - FUpdatePkU32TwoArgs ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_32_two"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU32Two(ReducerArgs)); } + FUpdateUniqueOptionI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI256(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU32Two(const FReducerEventContext& Context, const UUpdatePkU32TwoReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI256(const FReducerEventContext& Context, const UUpdateUniqueOptionI256Reducer* Args) { - if (!OnUpdatePkU32Two.IsBound()) + if (!OnUpdateUniqueOptionI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI256")); } return false; } - OnUpdatePkU32Two.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU32TwoWithArgs(const FReducerEventContext& Context, const FUpdatePkU32TwoArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI256Args& Args) { - if (!OnUpdatePkU32Two.IsBound()) + if (!OnUpdateUniqueOptionI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI256")); } return false; } - OnUpdatePkU32Two.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkU64(const uint64 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data) { if (!Conn) { @@ -12912,45 +16108,45 @@ void URemoteReducers::UpdatePkU64(const uint64 N, const int32 Data) return; } - FUpdatePkU64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU64(ReducerArgs)); } + FUpdateUniqueOptionI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU64(const FReducerEventContext& Context, const UUpdatePkU64Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI32(const FReducerEventContext& Context, const UUpdateUniqueOptionI32Reducer* Args) { - if (!OnUpdatePkU64.IsBound()) + if (!OnUpdateUniqueOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI32")); } return false; } - OnUpdatePkU64.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU64WithArgs(const FReducerEventContext& Context, const FUpdatePkU64Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI32Args& Args) { - if (!OnUpdatePkU64.IsBound()) + if (!OnUpdateUniqueOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI32")); } return false; } - OnUpdatePkU64.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkU8(const uint8 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data) { if (!Conn) { @@ -12958,45 +16154,45 @@ void URemoteReducers::UpdatePkU8(const uint8 N, const int32 Data) return; } - FUpdatePkU8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU8(ReducerArgs)); } + FUpdateUniqueOptionI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI64(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU8(const FReducerEventContext& Context, const UUpdatePkU8Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI64(const FReducerEventContext& Context, const UUpdateUniqueOptionI64Reducer* Args) { - if (!OnUpdatePkU8.IsBound()) + if (!OnUpdateUniqueOptionI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI64")); } return false; } - OnUpdatePkU8.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU8WithArgs(const FReducerEventContext& Context, const FUpdatePkU8Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI64Args& Args) { - if (!OnUpdatePkU8.IsBound()) + if (!OnUpdateUniqueOptionI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI64")); } return false; } - OnUpdatePkU8.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkUuid(const FSpacetimeDBUuid& U, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data) { if (!Conn) { @@ -13004,45 +16200,45 @@ void URemoteReducers::UpdatePkUuid(const FSpacetimeDBUuid& U, const int32 Data) return; } - FUpdatePkUuidArgs ReducerArgs(U, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkUuid(ReducerArgs)); } + FUpdateUniqueOptionI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI8(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkUuid(const FReducerEventContext& Context, const UUpdatePkUuidReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI8(const FReducerEventContext& Context, const UUpdateUniqueOptionI8Reducer* Args) { - if (!OnUpdatePkUuid.IsBound()) + if (!OnUpdateUniqueOptionI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI8")); } return false; } - OnUpdatePkUuid.Broadcast(Context, Args->U, Args->Data); + OnUpdateUniqueOptionI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkUuidWithArgs(const FReducerEventContext& Context, const FUpdatePkUuidArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI8Args& Args) { - if (!OnUpdatePkUuid.IsBound()) + if (!OnUpdateUniqueOptionI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI8")); } return false; } - OnUpdatePkUuid.Broadcast(Context, Args.U, Args.Data); + OnUpdateUniqueOptionI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueBool(const bool B, const int32 Data) +void URemoteReducers::UpdateUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data) { if (!Conn) { @@ -13050,45 +16246,45 @@ void URemoteReducers::UpdateUniqueBool(const bool B, const int32 Data) return; } - FUpdateUniqueBoolArgs ReducerArgs(B, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueBool(ReducerArgs)); } + FUpdateUniqueOptionIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueBool(const FReducerEventContext& Context, const UUpdateUniqueBoolReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionIdentity(const FReducerEventContext& Context, const UUpdateUniqueOptionIdentityReducer* Args) { - if (!OnUpdateUniqueBool.IsBound()) + if (!OnUpdateUniqueOptionIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionIdentity")); } return false; } - OnUpdateUniqueBool.Broadcast(Context, Args->B, Args->Data); + OnUpdateUniqueOptionIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueBoolWithArgs(const FReducerEventContext& Context, const FUpdateUniqueBoolArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionIdentityArgs& Args) { - if (!OnUpdateUniqueBool.IsBound()) + if (!OnUpdateUniqueOptionIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionIdentity")); } return false; } - OnUpdateUniqueBool.Broadcast(Context, Args.B, Args.Data); + OnUpdateUniqueOptionIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::UpdateUniqueConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) +void URemoteReducers::UpdateUniqueOptionString(const FTestClientOptionalString& S, const int32 Data) { if (!Conn) { @@ -13096,45 +16292,45 @@ void URemoteReducers::UpdateUniqueConnectionId(const FSpacetimeDBConnectionId& A return; } - FUpdateUniqueConnectionIdArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueConnectionId(ReducerArgs)); } + FUpdateUniqueOptionStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionString(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueConnectionId(const FReducerEventContext& Context, const UUpdateUniqueConnectionIdReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionString(const FReducerEventContext& Context, const UUpdateUniqueOptionStringReducer* Args) { - if (!OnUpdateUniqueConnectionId.IsBound()) + if (!OnUpdateUniqueOptionString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionString")); } return false; } - OnUpdateUniqueConnectionId.Broadcast(Context, Args->A, Args->Data); + OnUpdateUniqueOptionString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdateUniqueConnectionIdArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionStringArgs& Args) { - if (!OnUpdateUniqueConnectionId.IsBound()) + if (!OnUpdateUniqueOptionString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionString")); } return false; } - OnUpdateUniqueConnectionId.Broadcast(Context, Args.A, Args.Data); + OnUpdateUniqueOptionString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI128(const FSpacetimeDBInt128& N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data) { if (!Conn) { @@ -13142,45 +16338,45 @@ void URemoteReducers::UpdateUniqueI128(const FSpacetimeDBInt128& N, const int32 return; } - FUpdateUniqueI128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI128(ReducerArgs)); } + FUpdateUniqueOptionU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU128(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI128(const FReducerEventContext& Context, const UUpdateUniqueI128Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU128(const FReducerEventContext& Context, const UUpdateUniqueOptionU128Reducer* Args) { - if (!OnUpdateUniqueI128.IsBound()) + if (!OnUpdateUniqueOptionU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU128")); } return false; } - OnUpdateUniqueI128.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI128Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU128Args& Args) { - if (!OnUpdateUniqueI128.IsBound()) + if (!OnUpdateUniqueOptionU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU128")); } return false; } - OnUpdateUniqueI128.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI16(const int16 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data) { if (!Conn) { @@ -13188,45 +16384,45 @@ void URemoteReducers::UpdateUniqueI16(const int16 N, const int32 Data) return; } - FUpdateUniqueI16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI16(ReducerArgs)); } + FUpdateUniqueOptionU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU16(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI16(const FReducerEventContext& Context, const UUpdateUniqueI16Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU16(const FReducerEventContext& Context, const UUpdateUniqueOptionU16Reducer* Args) { - if (!OnUpdateUniqueI16.IsBound()) + if (!OnUpdateUniqueOptionU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU16")); } return false; } - OnUpdateUniqueI16.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI16Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU16Args& Args) { - if (!OnUpdateUniqueI16.IsBound()) + if (!OnUpdateUniqueOptionU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU16")); } return false; } - OnUpdateUniqueI16.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI256(const FSpacetimeDBInt256& N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data) { if (!Conn) { @@ -13234,45 +16430,45 @@ void URemoteReducers::UpdateUniqueI256(const FSpacetimeDBInt256& N, const int32 return; } - FUpdateUniqueI256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI256(ReducerArgs)); } + FUpdateUniqueOptionU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU256(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI256(const FReducerEventContext& Context, const UUpdateUniqueI256Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU256(const FReducerEventContext& Context, const UUpdateUniqueOptionU256Reducer* Args) { - if (!OnUpdateUniqueI256.IsBound()) + if (!OnUpdateUniqueOptionU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU256")); } return false; } - OnUpdateUniqueI256.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI256Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU256Args& Args) { - if (!OnUpdateUniqueI256.IsBound()) + if (!OnUpdateUniqueOptionU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU256")); } return false; } - OnUpdateUniqueI256.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI32(const int32 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data) { if (!Conn) { @@ -13280,45 +16476,45 @@ void URemoteReducers::UpdateUniqueI32(const int32 N, const int32 Data) return; } - FUpdateUniqueI32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI32(ReducerArgs)); } + FUpdateUniqueOptionU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU32(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI32(const FReducerEventContext& Context, const UUpdateUniqueI32Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU32(const FReducerEventContext& Context, const UUpdateUniqueOptionU32Reducer* Args) { - if (!OnUpdateUniqueI32.IsBound()) + if (!OnUpdateUniqueOptionU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU32")); } return false; } - OnUpdateUniqueI32.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI32Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU32Args& Args) { - if (!OnUpdateUniqueI32.IsBound()) + if (!OnUpdateUniqueOptionU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU32")); } return false; } - OnUpdateUniqueI32.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI64(const int64 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data) { if (!Conn) { @@ -13326,45 +16522,45 @@ void URemoteReducers::UpdateUniqueI64(const int64 N, const int32 Data) return; } - FUpdateUniqueI64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI64(ReducerArgs)); } + FUpdateUniqueOptionU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU64(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI64(const FReducerEventContext& Context, const UUpdateUniqueI64Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU64(const FReducerEventContext& Context, const UUpdateUniqueOptionU64Reducer* Args) { - if (!OnUpdateUniqueI64.IsBound()) + if (!OnUpdateUniqueOptionU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU64")); } return false; } - OnUpdateUniqueI64.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI64Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU64Args& Args) { - if (!OnUpdateUniqueI64.IsBound()) + if (!OnUpdateUniqueOptionU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU64")); } return false; } - OnUpdateUniqueI64.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI8(const int8 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data) { if (!Conn) { @@ -13372,45 +16568,45 @@ void URemoteReducers::UpdateUniqueI8(const int8 N, const int32 Data) return; } - FUpdateUniqueI8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI8(ReducerArgs)); } + FUpdateUniqueOptionU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU8(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI8(const FReducerEventContext& Context, const UUpdateUniqueI8Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU8(const FReducerEventContext& Context, const UUpdateUniqueOptionU8Reducer* Args) { - if (!OnUpdateUniqueI8.IsBound()) + if (!OnUpdateUniqueOptionU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU8")); } return false; } - OnUpdateUniqueI8.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI8Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU8Args& Args) { - if (!OnUpdateUniqueI8.IsBound()) + if (!OnUpdateUniqueOptionU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU8")); } return false; } - OnUpdateUniqueI8.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueIdentity(const FSpacetimeDBIdentity& I, const int32 Data) +void URemoteReducers::UpdateUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data) { if (!Conn) { @@ -13418,41 +16614,41 @@ void URemoteReducers::UpdateUniqueIdentity(const FSpacetimeDBIdentity& I, const return; } - FUpdateUniqueIdentityArgs ReducerArgs(I, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueIdentity(ReducerArgs)); } + FUpdateUniqueOptionUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueIdentity(const FReducerEventContext& Context, const UUpdateUniqueIdentityReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionUuid(const FReducerEventContext& Context, const UUpdateUniqueOptionUuidReducer* Args) { - if (!OnUpdateUniqueIdentity.IsBound()) + if (!OnUpdateUniqueOptionUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionUuid")); } return false; } - OnUpdateUniqueIdentity.Broadcast(Context, Args->I, Args->Data); + OnUpdateUniqueOptionUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueIdentityArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionUuidArgs& Args) { - if (!OnUpdateUniqueIdentity.IsBound()) + if (!OnUpdateUniqueOptionUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionUuid")); } return false; } - OnUpdateUniqueIdentity.Broadcast(Context, Args.I, Args.Data); + OnUpdateUniqueOptionUuid.Broadcast(Context, Args.U, Args.Data); return true; } @@ -14265,6 +17461,108 @@ void UDbConnection::ReducerEvent(const FReducerEvent& Event) Reducers->InvokeDeleteAllUniqueIdentityWithArgs(Context, Args); return; } + if (ReducerName == TEXT("delete_all_unique_option_bool")) + { + FDeleteAllUniqueOptionBoolArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionBool(); + Reducers->InvokeDeleteAllUniqueOptionBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_connection_id")) + { + FDeleteAllUniqueOptionConnectionIdArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionConnectionId(); + Reducers->InvokeDeleteAllUniqueOptionConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_128")) + { + FDeleteAllUniqueOptionI128Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI128(); + Reducers->InvokeDeleteAllUniqueOptionI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_16")) + { + FDeleteAllUniqueOptionI16Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI16(); + Reducers->InvokeDeleteAllUniqueOptionI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_256")) + { + FDeleteAllUniqueOptionI256Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI256(); + Reducers->InvokeDeleteAllUniqueOptionI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_32")) + { + FDeleteAllUniqueOptionI32Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI32(); + Reducers->InvokeDeleteAllUniqueOptionI32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_64")) + { + FDeleteAllUniqueOptionI64Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI64(); + Reducers->InvokeDeleteAllUniqueOptionI64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_8")) + { + FDeleteAllUniqueOptionI8Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI8(); + Reducers->InvokeDeleteAllUniqueOptionI8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_identity")) + { + FDeleteAllUniqueOptionIdentityArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionIdentity(); + Reducers->InvokeDeleteAllUniqueOptionIdentityWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_string")) + { + FDeleteAllUniqueOptionStringArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionString(); + Reducers->InvokeDeleteAllUniqueOptionStringWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_128")) + { + FDeleteAllUniqueOptionU128Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU128(); + Reducers->InvokeDeleteAllUniqueOptionU128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_16")) + { + FDeleteAllUniqueOptionU16Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU16(); + Reducers->InvokeDeleteAllUniqueOptionU16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_256")) + { + FDeleteAllUniqueOptionU256Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU256(); + Reducers->InvokeDeleteAllUniqueOptionU256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_32")) + { + FDeleteAllUniqueOptionU32Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU32(); + Reducers->InvokeDeleteAllUniqueOptionU32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_64")) + { + FDeleteAllUniqueOptionU64Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU64(); + Reducers->InvokeDeleteAllUniqueOptionU64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_8")) + { + FDeleteAllUniqueOptionU8Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU8(); + Reducers->InvokeDeleteAllUniqueOptionU8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_uuid")) + { + FDeleteAllUniqueOptionUuidArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionUuid(); + Reducers->InvokeDeleteAllUniqueOptionUuidWithArgs(Context, Args); + return; + } if (ReducerName == TEXT("delete_all_unique_string")) { FDeleteAllUniqueStringArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueString(); @@ -14573,74 +17871,176 @@ void UDbConnection::ReducerEvent(const FReducerEvent& Event) } if (ReducerName == TEXT("delete_pk_u_64")) { - FDeletePkU64Args Args = ReducerEvent.Reducer.GetAsDeletePkU64(); - Reducers->InvokeDeletePkU64WithArgs(Context, Args); + FDeletePkU64Args Args = ReducerEvent.Reducer.GetAsDeletePkU64(); + Reducers->InvokeDeletePkU64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_pk_u_8")) + { + FDeletePkU8Args Args = ReducerEvent.Reducer.GetAsDeletePkU8(); + Reducers->InvokeDeletePkU8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_pk_uuid")) + { + FDeletePkUuidArgs Args = ReducerEvent.Reducer.GetAsDeletePkUuid(); + Reducers->InvokeDeletePkUuidWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_bool")) + { + FDeleteUniqueBoolArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueBool(); + Reducers->InvokeDeleteUniqueBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_connection_id")) + { + FDeleteUniqueConnectionIdArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueConnectionId(); + Reducers->InvokeDeleteUniqueConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_128")) + { + FDeleteUniqueI128Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI128(); + Reducers->InvokeDeleteUniqueI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_16")) + { + FDeleteUniqueI16Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI16(); + Reducers->InvokeDeleteUniqueI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_256")) + { + FDeleteUniqueI256Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI256(); + Reducers->InvokeDeleteUniqueI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_32")) + { + FDeleteUniqueI32Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI32(); + Reducers->InvokeDeleteUniqueI32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_64")) + { + FDeleteUniqueI64Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI64(); + Reducers->InvokeDeleteUniqueI64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_8")) + { + FDeleteUniqueI8Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI8(); + Reducers->InvokeDeleteUniqueI8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_identity")) + { + FDeleteUniqueIdentityArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueIdentity(); + Reducers->InvokeDeleteUniqueIdentityWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_bool")) + { + FDeleteUniqueOptionBoolArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionBool(); + Reducers->InvokeDeleteUniqueOptionBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_connection_id")) + { + FDeleteUniqueOptionConnectionIdArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionConnectionId(); + Reducers->InvokeDeleteUniqueOptionConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_i_128")) + { + FDeleteUniqueOptionI128Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI128(); + Reducers->InvokeDeleteUniqueOptionI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_i_16")) + { + FDeleteUniqueOptionI16Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI16(); + Reducers->InvokeDeleteUniqueOptionI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_i_256")) + { + FDeleteUniqueOptionI256Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI256(); + Reducers->InvokeDeleteUniqueOptionI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_i_32")) + { + FDeleteUniqueOptionI32Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI32(); + Reducers->InvokeDeleteUniqueOptionI32WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_pk_u_8")) + if (ReducerName == TEXT("delete_unique_option_i_64")) { - FDeletePkU8Args Args = ReducerEvent.Reducer.GetAsDeletePkU8(); - Reducers->InvokeDeletePkU8WithArgs(Context, Args); + FDeleteUniqueOptionI64Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI64(); + Reducers->InvokeDeleteUniqueOptionI64WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_pk_uuid")) + if (ReducerName == TEXT("delete_unique_option_i_8")) { - FDeletePkUuidArgs Args = ReducerEvent.Reducer.GetAsDeletePkUuid(); - Reducers->InvokeDeletePkUuidWithArgs(Context, Args); + FDeleteUniqueOptionI8Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI8(); + Reducers->InvokeDeleteUniqueOptionI8WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_bool")) + if (ReducerName == TEXT("delete_unique_option_identity")) { - FDeleteUniqueBoolArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueBool(); - Reducers->InvokeDeleteUniqueBoolWithArgs(Context, Args); + FDeleteUniqueOptionIdentityArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionIdentity(); + Reducers->InvokeDeleteUniqueOptionIdentityWithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_connection_id")) + if (ReducerName == TEXT("delete_unique_option_string")) { - FDeleteUniqueConnectionIdArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueConnectionId(); - Reducers->InvokeDeleteUniqueConnectionIdWithArgs(Context, Args); + FDeleteUniqueOptionStringArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionString(); + Reducers->InvokeDeleteUniqueOptionStringWithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_128")) + if (ReducerName == TEXT("delete_unique_option_u_128")) { - FDeleteUniqueI128Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI128(); - Reducers->InvokeDeleteUniqueI128WithArgs(Context, Args); + FDeleteUniqueOptionU128Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU128(); + Reducers->InvokeDeleteUniqueOptionU128WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_16")) + if (ReducerName == TEXT("delete_unique_option_u_16")) { - FDeleteUniqueI16Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI16(); - Reducers->InvokeDeleteUniqueI16WithArgs(Context, Args); + FDeleteUniqueOptionU16Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU16(); + Reducers->InvokeDeleteUniqueOptionU16WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_256")) + if (ReducerName == TEXT("delete_unique_option_u_256")) { - FDeleteUniqueI256Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI256(); - Reducers->InvokeDeleteUniqueI256WithArgs(Context, Args); + FDeleteUniqueOptionU256Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU256(); + Reducers->InvokeDeleteUniqueOptionU256WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_32")) + if (ReducerName == TEXT("delete_unique_option_u_32")) { - FDeleteUniqueI32Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI32(); - Reducers->InvokeDeleteUniqueI32WithArgs(Context, Args); + FDeleteUniqueOptionU32Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU32(); + Reducers->InvokeDeleteUniqueOptionU32WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_64")) + if (ReducerName == TEXT("delete_unique_option_u_64")) { - FDeleteUniqueI64Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI64(); - Reducers->InvokeDeleteUniqueI64WithArgs(Context, Args); + FDeleteUniqueOptionU64Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU64(); + Reducers->InvokeDeleteUniqueOptionU64WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_8")) + if (ReducerName == TEXT("delete_unique_option_u_8")) { - FDeleteUniqueI8Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI8(); - Reducers->InvokeDeleteUniqueI8WithArgs(Context, Args); + FDeleteUniqueOptionU8Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU8(); + Reducers->InvokeDeleteUniqueOptionU8WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_identity")) + if (ReducerName == TEXT("delete_unique_option_uuid")) { - FDeleteUniqueIdentityArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueIdentity(); - Reducers->InvokeDeleteUniqueIdentityWithArgs(Context, Args); + FDeleteUniqueOptionUuidArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionUuid(); + Reducers->InvokeDeleteUniqueOptionUuidWithArgs(Context, Args); return; } if (ReducerName == TEXT("delete_unique_string")) @@ -15195,6 +18595,108 @@ void UDbConnection::ReducerEvent(const FReducerEvent& Event) Reducers->InvokeInsertUniqueIdentityWithArgs(Context, Args); return; } + if (ReducerName == TEXT("insert_unique_option_bool")) + { + FInsertUniqueOptionBoolArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionBool(); + Reducers->InvokeInsertUniqueOptionBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_connection_id")) + { + FInsertUniqueOptionConnectionIdArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionConnectionId(); + Reducers->InvokeInsertUniqueOptionConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_128")) + { + FInsertUniqueOptionI128Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI128(); + Reducers->InvokeInsertUniqueOptionI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_16")) + { + FInsertUniqueOptionI16Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI16(); + Reducers->InvokeInsertUniqueOptionI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_256")) + { + FInsertUniqueOptionI256Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI256(); + Reducers->InvokeInsertUniqueOptionI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_32")) + { + FInsertUniqueOptionI32Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI32(); + Reducers->InvokeInsertUniqueOptionI32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_64")) + { + FInsertUniqueOptionI64Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI64(); + Reducers->InvokeInsertUniqueOptionI64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_8")) + { + FInsertUniqueOptionI8Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI8(); + Reducers->InvokeInsertUniqueOptionI8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_identity")) + { + FInsertUniqueOptionIdentityArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionIdentity(); + Reducers->InvokeInsertUniqueOptionIdentityWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_string")) + { + FInsertUniqueOptionStringArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionString(); + Reducers->InvokeInsertUniqueOptionStringWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_128")) + { + FInsertUniqueOptionU128Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU128(); + Reducers->InvokeInsertUniqueOptionU128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_16")) + { + FInsertUniqueOptionU16Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU16(); + Reducers->InvokeInsertUniqueOptionU16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_256")) + { + FInsertUniqueOptionU256Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU256(); + Reducers->InvokeInsertUniqueOptionU256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_32")) + { + FInsertUniqueOptionU32Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU32(); + Reducers->InvokeInsertUniqueOptionU32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_64")) + { + FInsertUniqueOptionU64Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU64(); + Reducers->InvokeInsertUniqueOptionU64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_8")) + { + FInsertUniqueOptionU8Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU8(); + Reducers->InvokeInsertUniqueOptionU8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_uuid")) + { + FInsertUniqueOptionUuidArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionUuid(); + Reducers->InvokeInsertUniqueOptionUuidWithArgs(Context, Args); + return; + } if (ReducerName == TEXT("insert_unique_string")) { FInsertUniqueStringArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueString(); @@ -15597,6 +19099,108 @@ void UDbConnection::ReducerEvent(const FReducerEvent& Event) Reducers->InvokeUpdateUniqueIdentityWithArgs(Context, Args); return; } + if (ReducerName == TEXT("update_unique_option_bool")) + { + FUpdateUniqueOptionBoolArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionBool(); + Reducers->InvokeUpdateUniqueOptionBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_connection_id")) + { + FUpdateUniqueOptionConnectionIdArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionConnectionId(); + Reducers->InvokeUpdateUniqueOptionConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_128")) + { + FUpdateUniqueOptionI128Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI128(); + Reducers->InvokeUpdateUniqueOptionI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_16")) + { + FUpdateUniqueOptionI16Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI16(); + Reducers->InvokeUpdateUniqueOptionI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_256")) + { + FUpdateUniqueOptionI256Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI256(); + Reducers->InvokeUpdateUniqueOptionI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_32")) + { + FUpdateUniqueOptionI32Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI32(); + Reducers->InvokeUpdateUniqueOptionI32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_64")) + { + FUpdateUniqueOptionI64Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI64(); + Reducers->InvokeUpdateUniqueOptionI64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_8")) + { + FUpdateUniqueOptionI8Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI8(); + Reducers->InvokeUpdateUniqueOptionI8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_identity")) + { + FUpdateUniqueOptionIdentityArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionIdentity(); + Reducers->InvokeUpdateUniqueOptionIdentityWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_string")) + { + FUpdateUniqueOptionStringArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionString(); + Reducers->InvokeUpdateUniqueOptionStringWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_128")) + { + FUpdateUniqueOptionU128Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU128(); + Reducers->InvokeUpdateUniqueOptionU128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_16")) + { + FUpdateUniqueOptionU16Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU16(); + Reducers->InvokeUpdateUniqueOptionU16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_256")) + { + FUpdateUniqueOptionU256Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU256(); + Reducers->InvokeUpdateUniqueOptionU256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_32")) + { + FUpdateUniqueOptionU32Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU32(); + Reducers->InvokeUpdateUniqueOptionU32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_64")) + { + FUpdateUniqueOptionU64Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU64(); + Reducers->InvokeUpdateUniqueOptionU64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_8")) + { + FUpdateUniqueOptionU8Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU8(); + Reducers->InvokeUpdateUniqueOptionU8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_uuid")) + { + FUpdateUniqueOptionUuidArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionUuid(); + Reducers->InvokeUpdateUniqueOptionUuidWithArgs(Context, Args); + return; + } if (ReducerName == TEXT("update_unique_string")) { FUpdateUniqueStringArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueString(); @@ -16323,6 +19927,142 @@ USubscriptionBuilder* USubscriptionBuilder::AddUniqueIdentityQuery(const FUnique return AddBlueprintQuery(GenericQuery); } +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionBoolQuery(const FUniqueOptionBoolQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionConnectionIdQuery(const FUniqueOptionConnectionIdQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI128Query(const FUniqueOptionI128Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI16Query(const FUniqueOptionI16Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI256Query(const FUniqueOptionI256Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI32Query(const FUniqueOptionI32Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI64Query(const FUniqueOptionI64Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI8Query(const FUniqueOptionI8Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionIdentityQuery(const FUniqueOptionIdentityQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionStringQuery(const FUniqueOptionStringQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU128Query(const FUniqueOptionU128Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU16Query(const FUniqueOptionU16Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU256Query(const FUniqueOptionU256Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU32Query(const FUniqueOptionU32Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU64Query(const FUniqueOptionU64Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU8Query(const FUniqueOptionU8Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionUuidQuery(const FUniqueOptionUuidQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + USubscriptionBuilder* USubscriptionBuilder::AddUniqueStringQuery(const FUniqueStringQuery& Query) { FBlueprintQuery GenericQuery; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionBoolTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionBoolTable.g.cpp new file mode 100644 index 00000000000..c49fef259e2 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionBoolTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionBoolTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionBoolTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionBoolTable = Data->GetOrAdd(TableName); + UniqueOptionBoolTable->AddUniqueConstraint("b", [](const FUniqueOptionBoolType& Row) -> const FTestClientOptionalBool& { + return Row.B; }); + + B = NewObject(this); + B->SetCache(UniqueOptionBoolTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionBoolTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionBoolTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionBoolTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.cpp new file mode 100644 index 00000000000..70aef30a695 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionConnectionIdTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionConnectionIdTable = Data->GetOrAdd(TableName); + UniqueOptionConnectionIdTable->AddUniqueConstraint("a", [](const FUniqueOptionConnectionIdType& Row) -> const FTestClientOptionalConnectionId& { + return Row.A; }); + + A = NewObject(this); + A->SetCache(UniqueOptionConnectionIdTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionConnectionIdTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionConnectionIdTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionConnectionIdTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI128Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI128Table.g.cpp new file mode 100644 index 00000000000..0a8cd068bc8 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI128Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI128Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI128Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI128Table = Data->GetOrAdd(TableName); + UniqueOptionI128Table->AddUniqueConstraint("n", [](const FUniqueOptionI128Type& Row) -> const FTestClientOptionalInt128& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI128Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI128Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI128Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI128Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI16Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI16Table.g.cpp new file mode 100644 index 00000000000..a389db49a50 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI16Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI16Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI16Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI16Table = Data->GetOrAdd(TableName); + UniqueOptionI16Table->AddUniqueConstraint("n", [](const FUniqueOptionI16Type& Row) -> const FTestClientOptionalInt16& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI16Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI16Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI16Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI16Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI256Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI256Table.g.cpp new file mode 100644 index 00000000000..efb9c5a5c9a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI256Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI256Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI256Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI256Table = Data->GetOrAdd(TableName); + UniqueOptionI256Table->AddUniqueConstraint("n", [](const FUniqueOptionI256Type& Row) -> const FTestClientOptionalInt256& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI256Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI256Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI256Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI256Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI32Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI32Table.g.cpp new file mode 100644 index 00000000000..840084df71e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI32Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI32Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI32Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI32Table = Data->GetOrAdd(TableName); + UniqueOptionI32Table->AddUniqueConstraint("n", [](const FUniqueOptionI32Type& Row) -> const FTestClientOptionalInt32& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI32Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI32Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI32Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI32Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI64Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI64Table.g.cpp new file mode 100644 index 00000000000..139f9daf72d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI64Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI64Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI64Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI64Table = Data->GetOrAdd(TableName); + UniqueOptionI64Table->AddUniqueConstraint("n", [](const FUniqueOptionI64Type& Row) -> const FTestClientOptionalInt64& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI64Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI64Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI64Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI64Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI8Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI8Table.g.cpp new file mode 100644 index 00000000000..747d65726f1 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI8Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI8Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI8Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI8Table = Data->GetOrAdd(TableName); + UniqueOptionI8Table->AddUniqueConstraint("n", [](const FUniqueOptionI8Type& Row) -> const FTestClientOptionalInt8& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI8Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI8Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI8Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI8Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionIdentityTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionIdentityTable.g.cpp new file mode 100644 index 00000000000..3d5ea6a6122 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionIdentityTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionIdentityTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionIdentityTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionIdentityTable = Data->GetOrAdd(TableName); + UniqueOptionIdentityTable->AddUniqueConstraint("i", [](const FUniqueOptionIdentityType& Row) -> const FTestClientOptionalIdentity& { + return Row.I; }); + + I = NewObject(this); + I->SetCache(UniqueOptionIdentityTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionIdentityTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionIdentityTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionIdentityTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionStringTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionStringTable.g.cpp new file mode 100644 index 00000000000..b660d54d0df --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionStringTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionStringTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionStringTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionStringTable = Data->GetOrAdd(TableName); + UniqueOptionStringTable->AddUniqueConstraint("s", [](const FUniqueOptionStringType& Row) -> const FTestClientOptionalString& { + return Row.S; }); + + S = NewObject(this); + S->SetCache(UniqueOptionStringTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionStringTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionStringTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionStringTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU128Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU128Table.g.cpp new file mode 100644 index 00000000000..46faeee1454 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU128Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU128Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU128Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU128Table = Data->GetOrAdd(TableName); + UniqueOptionU128Table->AddUniqueConstraint("n", [](const FUniqueOptionU128Type& Row) -> const FTestClientOptionalUInt128& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU128Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU128Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU128Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU128Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU16Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU16Table.g.cpp new file mode 100644 index 00000000000..89c1d168bec --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU16Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU16Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU16Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU16Table = Data->GetOrAdd(TableName); + UniqueOptionU16Table->AddUniqueConstraint("n", [](const FUniqueOptionU16Type& Row) -> const FTestClientOptionalUInt16& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU16Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU16Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU16Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU16Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU256Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU256Table.g.cpp new file mode 100644 index 00000000000..c06864a9589 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU256Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU256Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU256Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU256Table = Data->GetOrAdd(TableName); + UniqueOptionU256Table->AddUniqueConstraint("n", [](const FUniqueOptionU256Type& Row) -> const FTestClientOptionalUInt256& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU256Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU256Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU256Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU256Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU32Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU32Table.g.cpp new file mode 100644 index 00000000000..3cc7af4ef1d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU32Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU32Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU32Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU32Table = Data->GetOrAdd(TableName); + UniqueOptionU32Table->AddUniqueConstraint("n", [](const FUniqueOptionU32Type& Row) -> const FTestClientOptionalUInt32& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU32Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU32Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU32Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU32Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU64Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU64Table.g.cpp new file mode 100644 index 00000000000..140e449a2bb --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU64Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU64Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU64Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU64Table = Data->GetOrAdd(TableName); + UniqueOptionU64Table->AddUniqueConstraint("n", [](const FUniqueOptionU64Type& Row) -> const FTestClientOptionalUInt64& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU64Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU64Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU64Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU64Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU8Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU8Table.g.cpp new file mode 100644 index 00000000000..9cc53b5d9a2 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU8Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU8Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU8Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU8Table = Data->GetOrAdd(TableName); + UniqueOptionU8Table->AddUniqueConstraint("n", [](const FUniqueOptionU8Type& Row) -> const FTestClientOptionalUInt8& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU8Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU8Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU8Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU8Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionUuidTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionUuidTable.g.cpp new file mode 100644 index 00000000000..f2c83b72942 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionUuidTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionUuidTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionUuidTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionUuidTable = Data->GetOrAdd(TableName); + UniqueOptionUuidTable->AddUniqueConstraint("u", [](const FUniqueOptionUuidType& Row) -> const FTestClientOptionalUuid& { + return Row.U; }); + + U = NewObject(this); + U->SetCache(UniqueOptionUuidTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionUuidTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionUuidTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionUuidTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/SpacetimeFullClientTests.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/SpacetimeFullClientTests.cpp index b66fa452282..17709481e45 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/SpacetimeFullClientTests.cpp +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/SpacetimeFullClientTests.cpp @@ -1187,6 +1187,74 @@ bool FInsertOptionNoneTest::RunTest(const FString &Parameters) return true; } +bool FDeleteOptionSomeTest::RunTest(const FString &Parameters) +{ + TestName = "DeleteOptionSome"; + + if (!ValidateParameterConfig(this)) + return false; + UDeleteOptionHandler *Handler = CreateTestHandler(); + Handler->bUseSome = true; + +#define REG_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ + Handler->Counter->Register(TEXT("InsertUniqueOption" #Suffix)); \ + Handler->Counter->Register(TEXT("DeleteUniqueOption" #Suffix)); + FOREACH_UNIQUE_OPTION_PRIMITIVE(REG_UNIQUE_OPTION) +#undef REG_UNIQUE_OPTION + + UDbConnection *Connection = ConnectThen(Handler->Counter, TestName, [this, Handler](UDbConnection *Conn) + { +#define BIND_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ + Conn->Db->UniqueOption##Suffix->OnInsert.AddDynamic(Handler, &UDeleteOptionHandler::OnInsertUniqueOption##Suffix); \ + Conn->Db->UniqueOption##Suffix->OnDelete.AddDynamic(Handler, &UDeleteOptionHandler::OnDeleteUniqueOption##Suffix); + FOREACH_UNIQUE_OPTION_PRIMITIVE(BIND_UNIQUE_OPTION) +#undef BIND_UNIQUE_OPTION + + SubscribeAllThen(Conn, [Handler](FSubscriptionEventContext Ctx) + { +#define CALL_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) Ctx.Reducers->InsertUniqueOption##Suffix(SomeLiteral, Expected); + FOREACH_UNIQUE_OPTION_PRIMITIVE(CALL_UNIQUE_OPTION) +#undef CALL_UNIQUE_OPTION + }); }); + + ADD_LATENT_AUTOMATION_COMMAND(FWaitForTestCounter(*this, TestName, Handler->Counter, FPlatformTime::Seconds())); + return true; +} + +bool FDeleteOptionNoneTest::RunTest(const FString &Parameters) +{ + TestName = "DeleteOptionNone"; + + if (!ValidateParameterConfig(this)) + return false; + UDeleteOptionHandler *Handler = CreateTestHandler(); + Handler->bUseSome = false; + +#define REG_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ + Handler->Counter->Register(TEXT("InsertUniqueOption" #Suffix)); \ + Handler->Counter->Register(TEXT("DeleteUniqueOption" #Suffix)); + FOREACH_UNIQUE_OPTION_PRIMITIVE(REG_UNIQUE_OPTION) +#undef REG_UNIQUE_OPTION + + UDbConnection *Connection = ConnectThen(Handler->Counter, TestName, [this, Handler](UDbConnection *Conn) + { +#define BIND_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ + Conn->Db->UniqueOption##Suffix->OnInsert.AddDynamic(Handler, &UDeleteOptionHandler::OnInsertUniqueOption##Suffix); \ + Conn->Db->UniqueOption##Suffix->OnDelete.AddDynamic(Handler, &UDeleteOptionHandler::OnDeleteUniqueOption##Suffix); + FOREACH_UNIQUE_OPTION_PRIMITIVE(BIND_UNIQUE_OPTION) +#undef BIND_UNIQUE_OPTION + + SubscribeAllThen(Conn, [Handler](FSubscriptionEventContext Ctx) + { +#define CALL_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) Ctx.Reducers->InsertUniqueOption##Suffix(NoneLiteral, Expected); + FOREACH_UNIQUE_OPTION_PRIMITIVE(CALL_UNIQUE_OPTION) +#undef CALL_UNIQUE_OPTION + }); }); + + ADD_LATENT_AUTOMATION_COMMAND(FWaitForTestCounter(*this, TestName, Handler->Counter, FPlatformTime::Seconds())); + return true; +} + bool FInsertResultOkTest::RunTest(const FString &Parameters) { TestName = "InsertResultOk"; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/TestHandler.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/TestHandler.cpp index 553f722e566..e3e346339a1 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/TestHandler.cpp +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/TestHandler.cpp @@ -50,6 +50,34 @@ void UDeletePrimitiveHandler::OnDeleteUnique##Suffix(const FEventContext& Contex FOREACH_UNIQUE_PRIMITIVE(DEFINE_DELETE_UNIQUE) #undef DEFINE_DELETE_UNIQUE +/* DeleteOption handler functions --------------------------------------- */ +#define DEFINE_DELETE_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ +void UDeleteOptionHandler::OnInsertUniqueOption##Suffix(const FEventContext& Context, const RowStructType& Value) \ +{ \ + static const FString Name(TEXT("InsertUniqueOption" #Suffix)); \ + RowStructType ExpectedValue; \ + ExpectedValue.Field = bUseSome ? SomeLiteral : NoneLiteral; \ + ExpectedValue.Data = Expected; \ + if (Value == ExpectedValue) { \ + Counter->MarkSuccess(Name); \ + } else { \ + Counter->MarkFailure(Name, TEXT("Unexpected value")); \ + } \ + Context.Reducers->DeleteUniqueOption##Suffix(Value.Field); \ +} \ + \ +void UDeleteOptionHandler::OnDeleteUniqueOption##Suffix(const FEventContext& Context, const RowStructType& Value) \ +{ \ + static const FString Name(TEXT("DeleteUniqueOption" #Suffix)); \ + RowStructType ExpectedValue; \ + ExpectedValue.Field = bUseSome ? SomeLiteral : NoneLiteral; \ + ExpectedValue.Data = Expected; \ + (Value == ExpectedValue) ? Counter->MarkSuccess(Name) : Counter->MarkFailure(Name, TEXT("Unexpected value")); \ +} + +FOREACH_UNIQUE_OPTION_PRIMITIVE(DEFINE_DELETE_UNIQUE_OPTION) +#undef DEFINE_DELETE_UNIQUE_OPTION + /* UpdatePrimitive handler functions ------------------------------------ */ #define DEFINE_UPDATE_PK(Suffix, Field, Literal, Expected, Updated, RowStructType) \ void UUpdatePrimitiveHandler::OnInsertPk##Suffix(const FEventContext& Context, const RowStructType& Value) \ diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalBool.g.h new file mode 100644 index 00000000000..c3a7d71e08d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalBool.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalBool.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalBool +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + bool Value = {}; + + FTestClientOptionalBool() = default; + + explicit FTestClientOptionalBool(const bool& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalBool& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalBool& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalBool. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalBool instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalBool& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalBool); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalBool, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h new file mode 100644 index 00000000000..ac323fb8e64 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "TestClientOptionalConnectionId.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalConnectionId +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBConnectionId Value = {}; + + FTestClientOptionalConnectionId() = default; + + explicit FTestClientOptionalConnectionId(const FSpacetimeDBConnectionId& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalConnectionId& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalConnectionId& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalConnectionId. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalConnectionId instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalConnectionId& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalConnectionId); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalConnectionId, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt128.g.h new file mode 100644 index 00000000000..c3a62450005 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt128.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/LargeIntegers.h" +#include "TestClientOptionalInt128.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt128 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBInt128 Value = {}; + + FTestClientOptionalInt128() = default; + + explicit FTestClientOptionalInt128(const FSpacetimeDBInt128& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt128& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt128& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt128. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt128 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt128& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt128); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt128, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt16.g.h new file mode 100644 index 00000000000..195106c8f66 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt16.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalInt16.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt16 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: int16 field not exposed to Blueprint due to non-blueprintable elements + int16 Value = {}; + + FTestClientOptionalInt16() = default; + + explicit FTestClientOptionalInt16(const int16& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt16& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt16& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt16. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt16 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt16& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt16); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt16, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt256.g.h new file mode 100644 index 00000000000..542b52566c9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt256.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/LargeIntegers.h" +#include "TestClientOptionalInt256.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt256 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBInt256 Value = {}; + + FTestClientOptionalInt256() = default; + + explicit FTestClientOptionalInt256(const FSpacetimeDBInt256& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt256& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt256& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt256. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt256 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt256& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt256); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt256, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt64.g.h new file mode 100644 index 00000000000..95967bd3dec --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt64.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalInt64.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt64 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + int64 Value = {}; + + FTestClientOptionalInt64() = default; + + explicit FTestClientOptionalInt64(const int64& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt64& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt64& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt64. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt64 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt64& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt64); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt64, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt8.g.h new file mode 100644 index 00000000000..6f84152a93b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt8.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalInt8.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt8 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: int8 field not exposed to Blueprint due to non-blueprintable elements + int8 Value = {}; + + FTestClientOptionalInt8() = default; + + explicit FTestClientOptionalInt8(const int8& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt8& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt8& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt8. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt8 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt8& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt8); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt8, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt128.g.h new file mode 100644 index 00000000000..40eab608920 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt128.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/LargeIntegers.h" +#include "TestClientOptionalUInt128.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt128 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBUInt128 Value = {}; + + FTestClientOptionalUInt128() = default; + + explicit FTestClientOptionalUInt128(const FSpacetimeDBUInt128& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt128& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt128& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt128. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt128 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt128& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt128); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt128, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt16.g.h new file mode 100644 index 00000000000..f7535a3e5ec --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt16.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalUInt16.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt16 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: uint16 field not exposed to Blueprint due to non-blueprintable elements + uint16 Value = {}; + + FTestClientOptionalUInt16() = default; + + explicit FTestClientOptionalUInt16(const uint16& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt16& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt16& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt16. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt16 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt16& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt16); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt16, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt256.g.h new file mode 100644 index 00000000000..1fbe787abb5 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt256.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/LargeIntegers.h" +#include "TestClientOptionalUInt256.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt256 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBUInt256 Value = {}; + + FTestClientOptionalUInt256() = default; + + explicit FTestClientOptionalUInt256(const FSpacetimeDBUInt256& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt256& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt256& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt256. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt256 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt256& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt256); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt256, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt32.g.h new file mode 100644 index 00000000000..573e8a3a25a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt32.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalUInt32.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt32 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: uint32 field not exposed to Blueprint due to non-blueprintable elements + uint32 Value = {}; + + FTestClientOptionalUInt32() = default; + + explicit FTestClientOptionalUInt32(const uint32& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt32& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt32& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt32. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt32 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt32& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt32); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt32, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt64.g.h new file mode 100644 index 00000000000..c7553763d94 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt64.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalUInt64.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt64 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: uint64 field not exposed to Blueprint due to non-blueprintable elements + uint64 Value = {}; + + FTestClientOptionalUInt64() = default; + + explicit FTestClientOptionalUInt64(const uint64& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt64& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt64& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt64. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt64 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt64& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt64); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt64, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt8.g.h new file mode 100644 index 00000000000..266d3c68793 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt8.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalUInt8.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt8 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + uint8 Value = {}; + + FTestClientOptionalUInt8() = default; + + explicit FTestClientOptionalUInt8(const uint8& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt8& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt8& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt8. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt8 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt8& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt8); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt8, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionBool.g.h new file mode 100644 index 00000000000..9a98e49302a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionBool.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionBool.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionBool +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionBoolArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalBool B; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionBoolArgs() = default; + + FDeleteAllUniqueOptionBoolArgs(const FTestClientOptionalBool& InB, const int32& InData) + : B(InB), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionBoolArgs& Other) const + { + return B == Other.B && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionBoolArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionBoolArgs, B, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionBoolReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalBool B; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionConnectionId.g.h new file mode 100644 index 00000000000..fe1de2f438e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionConnectionId.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionConnectionId.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionConnectionId +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionConnectionIdArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionConnectionIdArgs() = default; + + FDeleteAllUniqueOptionConnectionIdArgs(const FTestClientOptionalConnectionId& InA, const int32& InData) + : A(InA), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionConnectionIdArgs& Other) const + { + return A == Other.A && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionConnectionIdArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionConnectionIdArgs, A, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionConnectionIdReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI128.g.h new file mode 100644 index 00000000000..5f8496555b1 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionI128.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI128Args() = default; + + FDeleteAllUniqueOptionI128Args(const FTestClientOptionalInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI16.g.h new file mode 100644 index 00000000000..baa235ee5bb --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionI16.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI16Args() = default; + + FDeleteAllUniqueOptionI16Args(const FTestClientOptionalInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI256.g.h new file mode 100644 index 00000000000..21e9ffd0e8b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionI256.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI256Args() = default; + + FDeleteAllUniqueOptionI256Args(const FTestClientOptionalInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI32.g.h new file mode 100644 index 00000000000..633f9ed0980 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionI32.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI32Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI32Args() = default; + + FDeleteAllUniqueOptionI32Args(const FTestClientOptionalInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI64.g.h new file mode 100644 index 00000000000..37c6d5271b9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionI64.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI64Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI64Args() = default; + + FDeleteAllUniqueOptionI64Args(const FTestClientOptionalInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI8.g.h new file mode 100644 index 00000000000..1a1fd866af6 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionI8.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI8Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI8Args() = default; + + FDeleteAllUniqueOptionI8Args(const FTestClientOptionalInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionIdentity.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionIdentity.g.h new file mode 100644 index 00000000000..9eca8e44b97 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionIdentity.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionIdentity.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionIdentity +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionIdentityArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionIdentityArgs() = default; + + FDeleteAllUniqueOptionIdentityArgs(const FTestClientOptionalIdentity& InI, const int32& InData) + : I(InI), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionIdentityArgs& Other) const + { + return I == Other.I && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionIdentityArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionIdentityArgs, I, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionIdentityReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionString.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionString.g.h new file mode 100644 index 00000000000..3556cac30b6 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionString.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionString.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionString +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionStringArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalString S; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionStringArgs() = default; + + FDeleteAllUniqueOptionStringArgs(const FTestClientOptionalString& InS, const int32& InData) + : S(InS), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionStringArgs& Other) const + { + return S == Other.S && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionStringArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionStringArgs, S, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionStringReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalString S; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU128.g.h new file mode 100644 index 00000000000..3f53500e187 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionU128.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU128Args() = default; + + FDeleteAllUniqueOptionU128Args(const FTestClientOptionalUInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU16.g.h new file mode 100644 index 00000000000..4f33ae25547 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionU16.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU16Args() = default; + + FDeleteAllUniqueOptionU16Args(const FTestClientOptionalUInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU256.g.h new file mode 100644 index 00000000000..c80dc002d35 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionU256.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU256Args() = default; + + FDeleteAllUniqueOptionU256Args(const FTestClientOptionalUInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU32.g.h new file mode 100644 index 00000000000..8494a4ce777 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionU32.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU32Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU32Args() = default; + + FDeleteAllUniqueOptionU32Args(const FTestClientOptionalUInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU64.g.h new file mode 100644 index 00000000000..ff1ba95d537 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionU64.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU64Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU64Args() = default; + + FDeleteAllUniqueOptionU64Args(const FTestClientOptionalUInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU8.g.h new file mode 100644 index 00000000000..1da4417e0f9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionU8.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU8Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU8Args() = default; + + FDeleteAllUniqueOptionU8Args(const FTestClientOptionalUInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionUuid.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionUuid.g.h new file mode 100644 index 00000000000..5e6e9d382f8 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionUuid.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionUuid.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionUuid +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionUuidArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUuid U; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionUuidArgs() = default; + + FDeleteAllUniqueOptionUuidArgs(const FTestClientOptionalUuid& InU, const int32& InData) + : U(InU), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionUuidArgs& Other) const + { + return U == Other.U && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionUuidArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionUuidArgs, U, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionUuidReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUuid U; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionBool.g.h new file mode 100644 index 00000000000..e7ee9ea966c --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionBool.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionBool.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionBool +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionBoolArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalBool B; + + FDeleteUniqueOptionBoolArgs() = default; + + FDeleteUniqueOptionBoolArgs(const FTestClientOptionalBool& InB) + : B(InB) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionBoolArgs& Other) const + { + return B == Other.B; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionBoolArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionBoolArgs, B); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionBoolReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalBool B; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionConnectionId.g.h new file mode 100644 index 00000000000..41d7f91fc12 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionConnectionId.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionConnectionId.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionConnectionId +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionConnectionIdArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + + FDeleteUniqueOptionConnectionIdArgs() = default; + + FDeleteUniqueOptionConnectionIdArgs(const FTestClientOptionalConnectionId& InA) + : A(InA) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionConnectionIdArgs& Other) const + { + return A == Other.A; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionConnectionIdArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionConnectionIdArgs, A); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionConnectionIdReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI128.g.h new file mode 100644 index 00000000000..d2221b649a9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI128.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionI128.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + + FDeleteUniqueOptionI128Args() = default; + + FDeleteUniqueOptionI128Args(const FTestClientOptionalInt128& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI128Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI128Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI16.g.h new file mode 100644 index 00000000000..4c250f2371e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI16.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionI16.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + FDeleteUniqueOptionI16Args() = default; + + FDeleteUniqueOptionI16Args(const FTestClientOptionalInt16& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI16Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI16Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI256.g.h new file mode 100644 index 00000000000..a1110d89138 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI256.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionI256.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + + FDeleteUniqueOptionI256Args() = default; + + FDeleteUniqueOptionI256Args(const FTestClientOptionalInt256& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI256Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI256Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI32.g.h new file mode 100644 index 00000000000..2b6ceff829e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI32.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionI32.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI32Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + + FDeleteUniqueOptionI32Args() = default; + + FDeleteUniqueOptionI32Args(const FTestClientOptionalInt32& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI32Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI32Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI64.g.h new file mode 100644 index 00000000000..b9314160677 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI64.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionI64.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI64Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + + FDeleteUniqueOptionI64Args() = default; + + FDeleteUniqueOptionI64Args(const FTestClientOptionalInt64& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI64Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI64Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI8.g.h new file mode 100644 index 00000000000..ef9d577e5a5 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI8.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionI8.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI8Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + FDeleteUniqueOptionI8Args() = default; + + FDeleteUniqueOptionI8Args(const FTestClientOptionalInt8& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI8Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI8Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionIdentity.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionIdentity.g.h new file mode 100644 index 00000000000..9b404be0674 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionIdentity.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionIdentity.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionIdentity +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionIdentityArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + + FDeleteUniqueOptionIdentityArgs() = default; + + FDeleteUniqueOptionIdentityArgs(const FTestClientOptionalIdentity& InI) + : I(InI) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionIdentityArgs& Other) const + { + return I == Other.I; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionIdentityArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionIdentityArgs, I); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionIdentityReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionString.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionString.g.h new file mode 100644 index 00000000000..4279f076882 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionString.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionString.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionString +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionStringArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalString S; + + FDeleteUniqueOptionStringArgs() = default; + + FDeleteUniqueOptionStringArgs(const FTestClientOptionalString& InS) + : S(InS) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionStringArgs& Other) const + { + return S == Other.S; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionStringArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionStringArgs, S); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionStringReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalString S; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU128.g.h new file mode 100644 index 00000000000..16ce9978cd5 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU128.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionU128.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + + FDeleteUniqueOptionU128Args() = default; + + FDeleteUniqueOptionU128Args(const FTestClientOptionalUInt128& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU128Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU128Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU16.g.h new file mode 100644 index 00000000000..55ef7665cd7 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU16.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionU16.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + FDeleteUniqueOptionU16Args() = default; + + FDeleteUniqueOptionU16Args(const FTestClientOptionalUInt16& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU16Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU16Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU256.g.h new file mode 100644 index 00000000000..f49e5d5831b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU256.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionU256.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + + FDeleteUniqueOptionU256Args() = default; + + FDeleteUniqueOptionU256Args(const FTestClientOptionalUInt256& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU256Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU256Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU32.g.h new file mode 100644 index 00000000000..bb6dfd3ecad --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU32.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionU32.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU32Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + FDeleteUniqueOptionU32Args() = default; + + FDeleteUniqueOptionU32Args(const FTestClientOptionalUInt32& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU32Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU32Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU64.g.h new file mode 100644 index 00000000000..d66100b2c8d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU64.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionU64.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU64Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + FDeleteUniqueOptionU64Args() = default; + + FDeleteUniqueOptionU64Args(const FTestClientOptionalUInt64& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU64Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU64Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU8.g.h new file mode 100644 index 00000000000..748ffaa61ed --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU8.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionU8.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU8Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + + FDeleteUniqueOptionU8Args() = default; + + FDeleteUniqueOptionU8Args(const FTestClientOptionalUInt8& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU8Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU8Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionUuid.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionUuid.g.h new file mode 100644 index 00000000000..68175dfe8f3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionUuid.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionUuid.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionUuid +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionUuidArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUuid U; + + FDeleteUniqueOptionUuidArgs() = default; + + FDeleteUniqueOptionUuidArgs(const FTestClientOptionalUuid& InU) + : U(InU) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionUuidArgs& Other) const + { + return U == Other.U; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionUuidArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionUuidArgs, U); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionUuidReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUuid U; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionBool.g.h new file mode 100644 index 00000000000..a99f57b001e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionBool.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionBool.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionBool +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionBoolArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalBool B; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionBoolArgs() = default; + + FInsertUniqueOptionBoolArgs(const FTestClientOptionalBool& InB, const int32& InData) + : B(InB), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionBoolArgs& Other) const + { + return B == Other.B && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionBoolArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionBoolArgs, B, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionBoolReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalBool B; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionConnectionId.g.h new file mode 100644 index 00000000000..cadb3b70318 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionConnectionId.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionConnectionId.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionConnectionId +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionConnectionIdArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionConnectionIdArgs() = default; + + FInsertUniqueOptionConnectionIdArgs(const FTestClientOptionalConnectionId& InA, const int32& InData) + : A(InA), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionConnectionIdArgs& Other) const + { + return A == Other.A && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionConnectionIdArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionConnectionIdArgs, A, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionConnectionIdReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI128.g.h new file mode 100644 index 00000000000..23bea7a977d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionI128.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI128Args() = default; + + FInsertUniqueOptionI128Args(const FTestClientOptionalInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI16.g.h new file mode 100644 index 00000000000..45af3a85aa6 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionI16.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI16Args() = default; + + FInsertUniqueOptionI16Args(const FTestClientOptionalInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI256.g.h new file mode 100644 index 00000000000..daccf84f015 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionI256.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI256Args() = default; + + FInsertUniqueOptionI256Args(const FTestClientOptionalInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI32.g.h new file mode 100644 index 00000000000..b1de7b24a64 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionI32.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI32Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI32Args() = default; + + FInsertUniqueOptionI32Args(const FTestClientOptionalInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI64.g.h new file mode 100644 index 00000000000..d4411896ce4 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionI64.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI64Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI64Args() = default; + + FInsertUniqueOptionI64Args(const FTestClientOptionalInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI8.g.h new file mode 100644 index 00000000000..1aa15e36ecc --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionI8.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI8Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI8Args() = default; + + FInsertUniqueOptionI8Args(const FTestClientOptionalInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionIdentity.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionIdentity.g.h new file mode 100644 index 00000000000..87fd450b97d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionIdentity.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionIdentity.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionIdentity +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionIdentityArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionIdentityArgs() = default; + + FInsertUniqueOptionIdentityArgs(const FTestClientOptionalIdentity& InI, const int32& InData) + : I(InI), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionIdentityArgs& Other) const + { + return I == Other.I && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionIdentityArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionIdentityArgs, I, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionIdentityReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionString.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionString.g.h new file mode 100644 index 00000000000..2a3d23f947e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionString.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionString.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionString +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionStringArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalString S; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionStringArgs() = default; + + FInsertUniqueOptionStringArgs(const FTestClientOptionalString& InS, const int32& InData) + : S(InS), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionStringArgs& Other) const + { + return S == Other.S && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionStringArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionStringArgs, S, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionStringReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalString S; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU128.g.h new file mode 100644 index 00000000000..f1f08bfdf07 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionU128.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU128Args() = default; + + FInsertUniqueOptionU128Args(const FTestClientOptionalUInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU16.g.h new file mode 100644 index 00000000000..43a0e781ace --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionU16.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU16Args() = default; + + FInsertUniqueOptionU16Args(const FTestClientOptionalUInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU256.g.h new file mode 100644 index 00000000000..3ffc606a1a7 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionU256.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU256Args() = default; + + FInsertUniqueOptionU256Args(const FTestClientOptionalUInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU32.g.h new file mode 100644 index 00000000000..e4f9053524f --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionU32.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU32Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU32Args() = default; + + FInsertUniqueOptionU32Args(const FTestClientOptionalUInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU64.g.h new file mode 100644 index 00000000000..8d96a0870c3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionU64.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU64Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU64Args() = default; + + FInsertUniqueOptionU64Args(const FTestClientOptionalUInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU8.g.h new file mode 100644 index 00000000000..b76efbae67b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionU8.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU8Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU8Args() = default; + + FInsertUniqueOptionU8Args(const FTestClientOptionalUInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionUuid.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionUuid.g.h new file mode 100644 index 00000000000..b5fe2976d3c --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionUuid.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionUuid.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionUuid +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionUuidArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUuid U; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionUuidArgs() = default; + + FInsertUniqueOptionUuidArgs(const FTestClientOptionalUuid& InU, const int32& InData) + : U(InU), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionUuidArgs& Other) const + { + return U == Other.U && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionUuidArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionUuidArgs, U, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionUuidReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUuid U; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionBool.g.h new file mode 100644 index 00000000000..6e869f92efb --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionBool.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionBool.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionBool +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionBoolArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalBool B; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionBoolArgs() = default; + + FUpdateUniqueOptionBoolArgs(const FTestClientOptionalBool& InB, const int32& InData) + : B(InB), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionBoolArgs& Other) const + { + return B == Other.B && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionBoolArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionBoolArgs, B, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionBoolReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalBool B; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionConnectionId.g.h new file mode 100644 index 00000000000..9020567a5a0 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionConnectionId.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionConnectionId.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionConnectionId +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionConnectionIdArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionConnectionIdArgs() = default; + + FUpdateUniqueOptionConnectionIdArgs(const FTestClientOptionalConnectionId& InA, const int32& InData) + : A(InA), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionConnectionIdArgs& Other) const + { + return A == Other.A && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionConnectionIdArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionConnectionIdArgs, A, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionConnectionIdReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI128.g.h new file mode 100644 index 00000000000..6bfea671305 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionI128.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI128Args() = default; + + FUpdateUniqueOptionI128Args(const FTestClientOptionalInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI16.g.h new file mode 100644 index 00000000000..2cea8b44941 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionI16.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI16Args() = default; + + FUpdateUniqueOptionI16Args(const FTestClientOptionalInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI256.g.h new file mode 100644 index 00000000000..5465fff3c86 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionI256.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI256Args() = default; + + FUpdateUniqueOptionI256Args(const FTestClientOptionalInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI32.g.h new file mode 100644 index 00000000000..f44ffe1fa6b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionI32.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI32Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI32Args() = default; + + FUpdateUniqueOptionI32Args(const FTestClientOptionalInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI64.g.h new file mode 100644 index 00000000000..0e8c99c386a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionI64.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI64Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI64Args() = default; + + FUpdateUniqueOptionI64Args(const FTestClientOptionalInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI8.g.h new file mode 100644 index 00000000000..626d12b9cd6 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionI8.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI8Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI8Args() = default; + + FUpdateUniqueOptionI8Args(const FTestClientOptionalInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionIdentity.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionIdentity.g.h new file mode 100644 index 00000000000..6360e31708e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionIdentity.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionIdentity.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionIdentity +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionIdentityArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionIdentityArgs() = default; + + FUpdateUniqueOptionIdentityArgs(const FTestClientOptionalIdentity& InI, const int32& InData) + : I(InI), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionIdentityArgs& Other) const + { + return I == Other.I && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionIdentityArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionIdentityArgs, I, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionIdentityReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionString.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionString.g.h new file mode 100644 index 00000000000..6a13f036f3e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionString.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionString.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionString +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionStringArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalString S; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionStringArgs() = default; + + FUpdateUniqueOptionStringArgs(const FTestClientOptionalString& InS, const int32& InData) + : S(InS), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionStringArgs& Other) const + { + return S == Other.S && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionStringArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionStringArgs, S, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionStringReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalString S; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU128.g.h new file mode 100644 index 00000000000..e9d3de50e66 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionU128.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU128Args() = default; + + FUpdateUniqueOptionU128Args(const FTestClientOptionalUInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU16.g.h new file mode 100644 index 00000000000..b3f89e58e7e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionU16.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU16Args() = default; + + FUpdateUniqueOptionU16Args(const FTestClientOptionalUInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU256.g.h new file mode 100644 index 00000000000..572cf21ae1a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionU256.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU256Args() = default; + + FUpdateUniqueOptionU256Args(const FTestClientOptionalUInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU32.g.h new file mode 100644 index 00000000000..f8efa3d2052 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionU32.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU32Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU32Args() = default; + + FUpdateUniqueOptionU32Args(const FTestClientOptionalUInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU64.g.h new file mode 100644 index 00000000000..d4b84c45f9b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionU64.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU64Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU64Args() = default; + + FUpdateUniqueOptionU64Args(const FTestClientOptionalUInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU8.g.h new file mode 100644 index 00000000000..ea40e603648 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionU8.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU8Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU8Args() = default; + + FUpdateUniqueOptionU8Args(const FTestClientOptionalUInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionUuid.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionUuid.g.h new file mode 100644 index 00000000000..5ffa7a6b691 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionUuid.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionUuid.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionUuid +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionUuidArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUuid U; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionUuidArgs() = default; + + FUpdateUniqueOptionUuidArgs(const FTestClientOptionalUuid& InU, const int32& InData) + : U(InU), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionUuidArgs& Other) const + { + return U == Other.U && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionUuidArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionUuidArgs, U, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionUuidReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUuid U; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h index b6c7c76ec36..24e247be240 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h @@ -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.7.0 (commit 7b2d64cdf2e66aacac74ca7aaa0b4417100d380b). +// This was generated using spacetimedb cli version 2.7.0 (commit e64e7c0c15729126f00f2742ad3535cfa24da529). #pragma once #include "CoreMinimal.h" @@ -11,11 +11,24 @@ #include "Connection/DbConnectionBuilder.h" #include "Connection/Subscription.h" #include "Kismet/BlueprintFunctionLibrary.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" #include "ModuleBindings/Optionals/TestClientOptionalEveryPrimitiveStruct.g.h" #include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" #include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" #include "ModuleBindings/Optionals/TestClientOptionalSimpleEnum.g.h" #include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" #include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" #include "ModuleBindings/Optionals/TestClientOptionalVecOptionalInt32.g.h" #include "ModuleBindings/ReducerBase.g.h" @@ -78,6 +91,23 @@ #include "ModuleBindings/Reducers/DeleteAllUniqueI64.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueI8.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueIdentity.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionBool.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionConnectionId.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI128.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI16.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI256.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI32.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI64.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI8.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionIdentity.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionString.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU128.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU16.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU256.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU32.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU64.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU8.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionUuid.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueString.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueU128.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueU16.g.h" @@ -141,6 +171,23 @@ #include "ModuleBindings/Reducers/DeleteUniqueI64.g.h" #include "ModuleBindings/Reducers/DeleteUniqueI8.g.h" #include "ModuleBindings/Reducers/DeleteUniqueIdentity.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionBool.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionConnectionId.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI128.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI16.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI256.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI32.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI64.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI8.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionIdentity.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionString.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU128.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU16.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU256.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU32.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU64.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU8.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionUuid.g.h" #include "ModuleBindings/Reducers/DeleteUniqueString.g.h" #include "ModuleBindings/Reducers/DeleteUniqueU128.g.h" #include "ModuleBindings/Reducers/DeleteUniqueU16.g.h" @@ -233,6 +280,23 @@ #include "ModuleBindings/Reducers/InsertUniqueI64.g.h" #include "ModuleBindings/Reducers/InsertUniqueI8.g.h" #include "ModuleBindings/Reducers/InsertUniqueIdentity.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionBool.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionConnectionId.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI128.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI16.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI256.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI32.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI64.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI8.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionIdentity.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionString.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU128.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU16.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU256.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU32.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU64.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU8.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionUuid.g.h" #include "ModuleBindings/Reducers/InsertUniqueString.g.h" #include "ModuleBindings/Reducers/InsertUniqueU128.g.h" #include "ModuleBindings/Reducers/InsertUniqueU16.g.h" @@ -300,6 +364,23 @@ #include "ModuleBindings/Reducers/UpdateUniqueI64.g.h" #include "ModuleBindings/Reducers/UpdateUniqueI8.g.h" #include "ModuleBindings/Reducers/UpdateUniqueIdentity.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionBool.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionConnectionId.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI128.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI16.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI256.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI32.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI64.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI8.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionIdentity.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionString.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU128.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU16.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU256.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU32.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU64.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU8.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionUuid.g.h" #include "ModuleBindings/Reducers/UpdateUniqueString.g.h" #include "ModuleBindings/Reducers/UpdateUniqueU128.g.h" #include "ModuleBindings/Reducers/UpdateUniqueU16.g.h" @@ -391,6 +472,23 @@ #include "ModuleBindings/Types/UniqueI64Type.g.h" #include "ModuleBindings/Types/UniqueI8Type.g.h" #include "ModuleBindings/Types/UniqueIdentityType.g.h" +#include "ModuleBindings/Types/UniqueOptionBoolType.g.h" +#include "ModuleBindings/Types/UniqueOptionConnectionIdType.g.h" +#include "ModuleBindings/Types/UniqueOptionI128Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI16Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI256Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI32Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI64Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI8Type.g.h" +#include "ModuleBindings/Types/UniqueOptionIdentityType.g.h" +#include "ModuleBindings/Types/UniqueOptionStringType.g.h" +#include "ModuleBindings/Types/UniqueOptionU128Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU16Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU256Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU32Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU64Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU8Type.g.h" +#include "ModuleBindings/Types/UniqueOptionUuidType.g.h" #include "ModuleBindings/Types/UniqueStringType.g.h" #include "ModuleBindings/Types/UniqueU128Type.g.h" #include "ModuleBindings/Types/UniqueU16Type.g.h" @@ -512,6 +610,23 @@ class UUniqueI32Table; class UUniqueI64Table; class UUniqueI8Table; class UUniqueIdentityTable; +class UUniqueOptionBoolTable; +class UUniqueOptionConnectionIdTable; +class UUniqueOptionI128Table; +class UUniqueOptionI16Table; +class UUniqueOptionI256Table; +class UUniqueOptionI32Table; +class UUniqueOptionI64Table; +class UUniqueOptionI8Table; +class UUniqueOptionIdentityTable; +class UUniqueOptionStringTable; +class UUniqueOptionU128Table; +class UUniqueOptionU16Table; +class UUniqueOptionU256Table; +class UUniqueOptionU32Table; +class UUniqueOptionU64Table; +class UUniqueOptionU8Table; +class UUniqueOptionUuidTable; class UUniqueStringTable; class UUniqueU128Table; class UUniqueU16Table; @@ -674,6 +789,23 @@ enum class EReducerTag : int32 DeleteAllUniqueI64, DeleteAllUniqueI8, DeleteAllUniqueIdentity, + DeleteAllUniqueOptionBool, + DeleteAllUniqueOptionConnectionId, + DeleteAllUniqueOptionI128, + DeleteAllUniqueOptionI16, + DeleteAllUniqueOptionI256, + DeleteAllUniqueOptionI32, + DeleteAllUniqueOptionI64, + DeleteAllUniqueOptionI8, + DeleteAllUniqueOptionIdentity, + DeleteAllUniqueOptionString, + DeleteAllUniqueOptionU128, + DeleteAllUniqueOptionU16, + DeleteAllUniqueOptionU256, + DeleteAllUniqueOptionU32, + DeleteAllUniqueOptionU64, + DeleteAllUniqueOptionU8, + DeleteAllUniqueOptionUuid, DeleteAllUniqueString, DeleteAllUniqueU128, DeleteAllUniqueU16, @@ -737,6 +869,23 @@ enum class EReducerTag : int32 DeleteUniqueI64, DeleteUniqueI8, DeleteUniqueIdentity, + DeleteUniqueOptionBool, + DeleteUniqueOptionConnectionId, + DeleteUniqueOptionI128, + DeleteUniqueOptionI16, + DeleteUniqueOptionI256, + DeleteUniqueOptionI32, + DeleteUniqueOptionI64, + DeleteUniqueOptionI8, + DeleteUniqueOptionIdentity, + DeleteUniqueOptionString, + DeleteUniqueOptionU128, + DeleteUniqueOptionU16, + DeleteUniqueOptionU256, + DeleteUniqueOptionU32, + DeleteUniqueOptionU64, + DeleteUniqueOptionU8, + DeleteUniqueOptionUuid, DeleteUniqueString, DeleteUniqueU128, DeleteUniqueU16, @@ -829,6 +978,23 @@ enum class EReducerTag : int32 InsertUniqueI64, InsertUniqueI8, InsertUniqueIdentity, + InsertUniqueOptionBool, + InsertUniqueOptionConnectionId, + InsertUniqueOptionI128, + InsertUniqueOptionI16, + InsertUniqueOptionI256, + InsertUniqueOptionI32, + InsertUniqueOptionI64, + InsertUniqueOptionI8, + InsertUniqueOptionIdentity, + InsertUniqueOptionString, + InsertUniqueOptionU128, + InsertUniqueOptionU16, + InsertUniqueOptionU256, + InsertUniqueOptionU32, + InsertUniqueOptionU64, + InsertUniqueOptionU8, + InsertUniqueOptionUuid, InsertUniqueString, InsertUniqueU128, InsertUniqueU16, @@ -896,6 +1062,23 @@ enum class EReducerTag : int32 UpdateUniqueI64, UpdateUniqueI8, UpdateUniqueIdentity, + UpdateUniqueOptionBool, + UpdateUniqueOptionConnectionId, + UpdateUniqueOptionI128, + UpdateUniqueOptionI16, + UpdateUniqueOptionI256, + UpdateUniqueOptionI32, + UpdateUniqueOptionI64, + UpdateUniqueOptionI8, + UpdateUniqueOptionIdentity, + UpdateUniqueOptionString, + UpdateUniqueOptionU128, + UpdateUniqueOptionU16, + UpdateUniqueOptionU256, + UpdateUniqueOptionU32, + UpdateUniqueOptionU64, + UpdateUniqueOptionU8, + UpdateUniqueOptionUuid, UpdateUniqueString, UpdateUniqueU128, UpdateUniqueU16, @@ -1997,6 +2180,312 @@ struct TESTCLIENT_API FReducer return TypedData ? TypedData->Value : FDeleteAllUniqueIdentityArgs(); } + static FReducer DeleteAllUniqueOptionBool(const FDeleteAllUniqueOptionBoolArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionBool); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_bool"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionBool() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionBool); } + FORCEINLINE FDeleteAllUniqueOptionBoolArgs GetAsDeleteAllUniqueOptionBool() const + { + ensureMsgf(IsDeleteAllUniqueOptionBool(), TEXT("Reducer does not hold DeleteAllUniqueOptionBool!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionBool!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionBoolArgs(); + } + + static FReducer DeleteAllUniqueOptionConnectionId(const FDeleteAllUniqueOptionConnectionIdArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_connection_id"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionConnectionId() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionConnectionId); } + FORCEINLINE FDeleteAllUniqueOptionConnectionIdArgs GetAsDeleteAllUniqueOptionConnectionId() const + { + ensureMsgf(IsDeleteAllUniqueOptionConnectionId(), TEXT("Reducer does not hold DeleteAllUniqueOptionConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionConnectionId!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionConnectionIdArgs(); + } + + static FReducer DeleteAllUniqueOptionI128(const FDeleteAllUniqueOptionI128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_128"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI128() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI128); } + FORCEINLINE FDeleteAllUniqueOptionI128Args GetAsDeleteAllUniqueOptionI128() const + { + ensureMsgf(IsDeleteAllUniqueOptionI128(), TEXT("Reducer does not hold DeleteAllUniqueOptionI128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI128!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI128Args(); + } + + static FReducer DeleteAllUniqueOptionI16(const FDeleteAllUniqueOptionI16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_16"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI16() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI16); } + FORCEINLINE FDeleteAllUniqueOptionI16Args GetAsDeleteAllUniqueOptionI16() const + { + ensureMsgf(IsDeleteAllUniqueOptionI16(), TEXT("Reducer does not hold DeleteAllUniqueOptionI16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI16!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI16Args(); + } + + static FReducer DeleteAllUniqueOptionI256(const FDeleteAllUniqueOptionI256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_256"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI256() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI256); } + FORCEINLINE FDeleteAllUniqueOptionI256Args GetAsDeleteAllUniqueOptionI256() const + { + ensureMsgf(IsDeleteAllUniqueOptionI256(), TEXT("Reducer does not hold DeleteAllUniqueOptionI256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI256!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI256Args(); + } + + static FReducer DeleteAllUniqueOptionI32(const FDeleteAllUniqueOptionI32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_32"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI32() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI32); } + FORCEINLINE FDeleteAllUniqueOptionI32Args GetAsDeleteAllUniqueOptionI32() const + { + ensureMsgf(IsDeleteAllUniqueOptionI32(), TEXT("Reducer does not hold DeleteAllUniqueOptionI32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI32!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI32Args(); + } + + static FReducer DeleteAllUniqueOptionI64(const FDeleteAllUniqueOptionI64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_64"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI64() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI64); } + FORCEINLINE FDeleteAllUniqueOptionI64Args GetAsDeleteAllUniqueOptionI64() const + { + ensureMsgf(IsDeleteAllUniqueOptionI64(), TEXT("Reducer does not hold DeleteAllUniqueOptionI64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI64!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI64Args(); + } + + static FReducer DeleteAllUniqueOptionI8(const FDeleteAllUniqueOptionI8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_8"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI8() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI8); } + FORCEINLINE FDeleteAllUniqueOptionI8Args GetAsDeleteAllUniqueOptionI8() const + { + ensureMsgf(IsDeleteAllUniqueOptionI8(), TEXT("Reducer does not hold DeleteAllUniqueOptionI8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI8!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI8Args(); + } + + static FReducer DeleteAllUniqueOptionIdentity(const FDeleteAllUniqueOptionIdentityArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionIdentity); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_identity"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionIdentity() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionIdentity); } + FORCEINLINE FDeleteAllUniqueOptionIdentityArgs GetAsDeleteAllUniqueOptionIdentity() const + { + ensureMsgf(IsDeleteAllUniqueOptionIdentity(), TEXT("Reducer does not hold DeleteAllUniqueOptionIdentity!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionIdentity!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionIdentityArgs(); + } + + static FReducer DeleteAllUniqueOptionString(const FDeleteAllUniqueOptionStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_string"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionString() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionString); } + FORCEINLINE FDeleteAllUniqueOptionStringArgs GetAsDeleteAllUniqueOptionString() const + { + ensureMsgf(IsDeleteAllUniqueOptionString(), TEXT("Reducer does not hold DeleteAllUniqueOptionString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionString!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionStringArgs(); + } + + static FReducer DeleteAllUniqueOptionU128(const FDeleteAllUniqueOptionU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_128"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU128() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU128); } + FORCEINLINE FDeleteAllUniqueOptionU128Args GetAsDeleteAllUniqueOptionU128() const + { + ensureMsgf(IsDeleteAllUniqueOptionU128(), TEXT("Reducer does not hold DeleteAllUniqueOptionU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU128!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU128Args(); + } + + static FReducer DeleteAllUniqueOptionU16(const FDeleteAllUniqueOptionU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_16"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU16() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU16); } + FORCEINLINE FDeleteAllUniqueOptionU16Args GetAsDeleteAllUniqueOptionU16() const + { + ensureMsgf(IsDeleteAllUniqueOptionU16(), TEXT("Reducer does not hold DeleteAllUniqueOptionU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU16!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU16Args(); + } + + static FReducer DeleteAllUniqueOptionU256(const FDeleteAllUniqueOptionU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_256"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU256() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU256); } + FORCEINLINE FDeleteAllUniqueOptionU256Args GetAsDeleteAllUniqueOptionU256() const + { + ensureMsgf(IsDeleteAllUniqueOptionU256(), TEXT("Reducer does not hold DeleteAllUniqueOptionU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU256!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU256Args(); + } + + static FReducer DeleteAllUniqueOptionU32(const FDeleteAllUniqueOptionU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_32"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU32() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU32); } + FORCEINLINE FDeleteAllUniqueOptionU32Args GetAsDeleteAllUniqueOptionU32() const + { + ensureMsgf(IsDeleteAllUniqueOptionU32(), TEXT("Reducer does not hold DeleteAllUniqueOptionU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU32!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU32Args(); + } + + static FReducer DeleteAllUniqueOptionU64(const FDeleteAllUniqueOptionU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_64"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU64() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU64); } + FORCEINLINE FDeleteAllUniqueOptionU64Args GetAsDeleteAllUniqueOptionU64() const + { + ensureMsgf(IsDeleteAllUniqueOptionU64(), TEXT("Reducer does not hold DeleteAllUniqueOptionU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU64!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU64Args(); + } + + static FReducer DeleteAllUniqueOptionU8(const FDeleteAllUniqueOptionU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_8"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU8() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU8); } + FORCEINLINE FDeleteAllUniqueOptionU8Args GetAsDeleteAllUniqueOptionU8() const + { + ensureMsgf(IsDeleteAllUniqueOptionU8(), TEXT("Reducer does not hold DeleteAllUniqueOptionU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU8!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU8Args(); + } + + static FReducer DeleteAllUniqueOptionUuid(const FDeleteAllUniqueOptionUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_uuid"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionUuid() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionUuid); } + FORCEINLINE FDeleteAllUniqueOptionUuidArgs GetAsDeleteAllUniqueOptionUuid() const + { + ensureMsgf(IsDeleteAllUniqueOptionUuid(), TEXT("Reducer does not hold DeleteAllUniqueOptionUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionUuid!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionUuidArgs(); + } + static FReducer DeleteAllUniqueString(const FDeleteAllUniqueStringArgs& Value) { FReducer Out; @@ -3131,220 +3620,526 @@ struct TESTCLIENT_API FReducer return TypedData ? TypedData->Value : FDeleteUniqueIdentityArgs(); } - static FReducer DeleteUniqueString(const FDeleteUniqueStringArgs& Value) + static FReducer DeleteUniqueOptionBool(const FDeleteUniqueOptionBoolArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueString); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_string"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionBool); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_bool"); return Out; } - FORCEINLINE bool IsDeleteUniqueString() const { return Tag == static_cast(EReducerTag::DeleteUniqueString); } - FORCEINLINE FDeleteUniqueStringArgs GetAsDeleteUniqueString() const + FORCEINLINE bool IsDeleteUniqueOptionBool() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionBool); } + FORCEINLINE FDeleteUniqueOptionBoolArgs GetAsDeleteUniqueOptionBool() const { - ensureMsgf(IsDeleteUniqueString(), TEXT("Reducer does not hold DeleteUniqueString!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueString!")); - return TypedData ? TypedData->Value : FDeleteUniqueStringArgs(); + ensureMsgf(IsDeleteUniqueOptionBool(), TEXT("Reducer does not hold DeleteUniqueOptionBool!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionBool!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionBoolArgs(); } - static FReducer DeleteUniqueU128(const FDeleteUniqueU128Args& Value) + static FReducer DeleteUniqueOptionConnectionId(const FDeleteUniqueOptionConnectionIdArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU128); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_128"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_connection_id"); return Out; } - FORCEINLINE bool IsDeleteUniqueU128() const { return Tag == static_cast(EReducerTag::DeleteUniqueU128); } - FORCEINLINE FDeleteUniqueU128Args GetAsDeleteUniqueU128() const + FORCEINLINE bool IsDeleteUniqueOptionConnectionId() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionConnectionId); } + FORCEINLINE FDeleteUniqueOptionConnectionIdArgs GetAsDeleteUniqueOptionConnectionId() const { - ensureMsgf(IsDeleteUniqueU128(), TEXT("Reducer does not hold DeleteUniqueU128!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU128!")); - return TypedData ? TypedData->Value : FDeleteUniqueU128Args(); + ensureMsgf(IsDeleteUniqueOptionConnectionId(), TEXT("Reducer does not hold DeleteUniqueOptionConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionConnectionId!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionConnectionIdArgs(); } - static FReducer DeleteUniqueU16(const FDeleteUniqueU16Args& Value) + static FReducer DeleteUniqueOptionI128(const FDeleteUniqueOptionI128Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU16); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_16"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_128"); return Out; } - FORCEINLINE bool IsDeleteUniqueU16() const { return Tag == static_cast(EReducerTag::DeleteUniqueU16); } - FORCEINLINE FDeleteUniqueU16Args GetAsDeleteUniqueU16() const + FORCEINLINE bool IsDeleteUniqueOptionI128() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI128); } + FORCEINLINE FDeleteUniqueOptionI128Args GetAsDeleteUniqueOptionI128() const { - ensureMsgf(IsDeleteUniqueU16(), TEXT("Reducer does not hold DeleteUniqueU16!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU16!")); - return TypedData ? TypedData->Value : FDeleteUniqueU16Args(); + ensureMsgf(IsDeleteUniqueOptionI128(), TEXT("Reducer does not hold DeleteUniqueOptionI128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI128!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI128Args(); } - static FReducer DeleteUniqueU256(const FDeleteUniqueU256Args& Value) + static FReducer DeleteUniqueOptionI16(const FDeleteUniqueOptionI16Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU256); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_256"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_16"); return Out; } - FORCEINLINE bool IsDeleteUniqueU256() const { return Tag == static_cast(EReducerTag::DeleteUniqueU256); } - FORCEINLINE FDeleteUniqueU256Args GetAsDeleteUniqueU256() const + FORCEINLINE bool IsDeleteUniqueOptionI16() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI16); } + FORCEINLINE FDeleteUniqueOptionI16Args GetAsDeleteUniqueOptionI16() const { - ensureMsgf(IsDeleteUniqueU256(), TEXT("Reducer does not hold DeleteUniqueU256!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU256!")); - return TypedData ? TypedData->Value : FDeleteUniqueU256Args(); + ensureMsgf(IsDeleteUniqueOptionI16(), TEXT("Reducer does not hold DeleteUniqueOptionI16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI16!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI16Args(); } - static FReducer DeleteUniqueU32(const FDeleteUniqueU32Args& Value) + static FReducer DeleteUniqueOptionI256(const FDeleteUniqueOptionI256Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU32); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_32"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_256"); return Out; } - FORCEINLINE bool IsDeleteUniqueU32() const { return Tag == static_cast(EReducerTag::DeleteUniqueU32); } - FORCEINLINE FDeleteUniqueU32Args GetAsDeleteUniqueU32() const + FORCEINLINE bool IsDeleteUniqueOptionI256() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI256); } + FORCEINLINE FDeleteUniqueOptionI256Args GetAsDeleteUniqueOptionI256() const { - ensureMsgf(IsDeleteUniqueU32(), TEXT("Reducer does not hold DeleteUniqueU32!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU32!")); - return TypedData ? TypedData->Value : FDeleteUniqueU32Args(); + ensureMsgf(IsDeleteUniqueOptionI256(), TEXT("Reducer does not hold DeleteUniqueOptionI256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI256!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI256Args(); } - static FReducer DeleteUniqueU64(const FDeleteUniqueU64Args& Value) + static FReducer DeleteUniqueOptionI32(const FDeleteUniqueOptionI32Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU64); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_64"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_32"); return Out; } - FORCEINLINE bool IsDeleteUniqueU64() const { return Tag == static_cast(EReducerTag::DeleteUniqueU64); } - FORCEINLINE FDeleteUniqueU64Args GetAsDeleteUniqueU64() const + FORCEINLINE bool IsDeleteUniqueOptionI32() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI32); } + FORCEINLINE FDeleteUniqueOptionI32Args GetAsDeleteUniqueOptionI32() const { - ensureMsgf(IsDeleteUniqueU64(), TEXT("Reducer does not hold DeleteUniqueU64!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU64!")); - return TypedData ? TypedData->Value : FDeleteUniqueU64Args(); + ensureMsgf(IsDeleteUniqueOptionI32(), TEXT("Reducer does not hold DeleteUniqueOptionI32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI32!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI32Args(); } - static FReducer DeleteUniqueU8(const FDeleteUniqueU8Args& Value) + static FReducer DeleteUniqueOptionI64(const FDeleteUniqueOptionI64Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU8); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_8"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_64"); return Out; } - FORCEINLINE bool IsDeleteUniqueU8() const { return Tag == static_cast(EReducerTag::DeleteUniqueU8); } - FORCEINLINE FDeleteUniqueU8Args GetAsDeleteUniqueU8() const + FORCEINLINE bool IsDeleteUniqueOptionI64() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI64); } + FORCEINLINE FDeleteUniqueOptionI64Args GetAsDeleteUniqueOptionI64() const { - ensureMsgf(IsDeleteUniqueU8(), TEXT("Reducer does not hold DeleteUniqueU8!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU8!")); - return TypedData ? TypedData->Value : FDeleteUniqueU8Args(); + ensureMsgf(IsDeleteUniqueOptionI64(), TEXT("Reducer does not hold DeleteUniqueOptionI64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI64!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI64Args(); } - static FReducer DeleteUniqueUuid(const FDeleteUniqueUuidArgs& Value) + static FReducer DeleteUniqueOptionI8(const FDeleteUniqueOptionI8Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueUuid); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_uuid"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_8"); return Out; } - FORCEINLINE bool IsDeleteUniqueUuid() const { return Tag == static_cast(EReducerTag::DeleteUniqueUuid); } - FORCEINLINE FDeleteUniqueUuidArgs GetAsDeleteUniqueUuid() const + FORCEINLINE bool IsDeleteUniqueOptionI8() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI8); } + FORCEINLINE FDeleteUniqueOptionI8Args GetAsDeleteUniqueOptionI8() const { - ensureMsgf(IsDeleteUniqueUuid(), TEXT("Reducer does not hold DeleteUniqueUuid!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueUuid!")); - return TypedData ? TypedData->Value : FDeleteUniqueUuidArgs(); + ensureMsgf(IsDeleteUniqueOptionI8(), TEXT("Reducer does not hold DeleteUniqueOptionI8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI8!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI8Args(); } - static FReducer InsertCallTimestamp(const FInsertCallTimestampArgs& Value) + static FReducer DeleteUniqueOptionIdentity(const FDeleteUniqueOptionIdentityArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::InsertCallTimestamp); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("insert_call_timestamp"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionIdentity); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_identity"); return Out; } - FORCEINLINE bool IsInsertCallTimestamp() const { return Tag == static_cast(EReducerTag::InsertCallTimestamp); } - FORCEINLINE FInsertCallTimestampArgs GetAsInsertCallTimestamp() const + FORCEINLINE bool IsDeleteUniqueOptionIdentity() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionIdentity); } + FORCEINLINE FDeleteUniqueOptionIdentityArgs GetAsDeleteUniqueOptionIdentity() const { - ensureMsgf(IsInsertCallTimestamp(), TEXT("Reducer does not hold InsertCallTimestamp!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallTimestamp!")); - return TypedData ? TypedData->Value : FInsertCallTimestampArgs(); + ensureMsgf(IsDeleteUniqueOptionIdentity(), TEXT("Reducer does not hold DeleteUniqueOptionIdentity!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionIdentity!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionIdentityArgs(); } - static FReducer InsertCallUuidV4(const FInsertCallUuidV4Args& Value) + static FReducer DeleteUniqueOptionString(const FDeleteUniqueOptionStringArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::InsertCallUuidV4); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("insert_call_uuid_v_4"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_string"); return Out; } - FORCEINLINE bool IsInsertCallUuidV4() const { return Tag == static_cast(EReducerTag::InsertCallUuidV4); } - FORCEINLINE FInsertCallUuidV4Args GetAsInsertCallUuidV4() const + FORCEINLINE bool IsDeleteUniqueOptionString() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionString); } + FORCEINLINE FDeleteUniqueOptionStringArgs GetAsDeleteUniqueOptionString() const { - ensureMsgf(IsInsertCallUuidV4(), TEXT("Reducer does not hold InsertCallUuidV4!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallUuidV4!")); - return TypedData ? TypedData->Value : FInsertCallUuidV4Args(); + ensureMsgf(IsDeleteUniqueOptionString(), TEXT("Reducer does not hold DeleteUniqueOptionString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionString!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionStringArgs(); } - static FReducer InsertCallUuidV7(const FInsertCallUuidV7Args& Value) + static FReducer DeleteUniqueOptionU128(const FDeleteUniqueOptionU128Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::InsertCallUuidV7); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("insert_call_uuid_v_7"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_128"); return Out; } - FORCEINLINE bool IsInsertCallUuidV7() const { return Tag == static_cast(EReducerTag::InsertCallUuidV7); } - FORCEINLINE FInsertCallUuidV7Args GetAsInsertCallUuidV7() const + FORCEINLINE bool IsDeleteUniqueOptionU128() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU128); } + FORCEINLINE FDeleteUniqueOptionU128Args GetAsDeleteUniqueOptionU128() const { - ensureMsgf(IsInsertCallUuidV7(), TEXT("Reducer does not hold InsertCallUuidV7!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallUuidV7!")); - return TypedData ? TypedData->Value : FInsertCallUuidV7Args(); + ensureMsgf(IsDeleteUniqueOptionU128(), TEXT("Reducer does not hold DeleteUniqueOptionU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU128!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU128Args(); } - static FReducer InsertCallerOneConnectionId(const FInsertCallerOneConnectionIdArgs& Value) + static FReducer DeleteUniqueOptionU16(const FDeleteUniqueOptionU16Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::InsertCallerOneConnectionId); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("insert_caller_one_connection_id"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_16"); return Out; } - FORCEINLINE bool IsInsertCallerOneConnectionId() const { return Tag == static_cast(EReducerTag::InsertCallerOneConnectionId); } - FORCEINLINE FInsertCallerOneConnectionIdArgs GetAsInsertCallerOneConnectionId() const + FORCEINLINE bool IsDeleteUniqueOptionU16() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU16); } + FORCEINLINE FDeleteUniqueOptionU16Args GetAsDeleteUniqueOptionU16() const { - ensureMsgf(IsInsertCallerOneConnectionId(), TEXT("Reducer does not hold InsertCallerOneConnectionId!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallerOneConnectionId!")); - return TypedData ? TypedData->Value : FInsertCallerOneConnectionIdArgs(); + ensureMsgf(IsDeleteUniqueOptionU16(), TEXT("Reducer does not hold DeleteUniqueOptionU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU16!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU16Args(); + } + + static FReducer DeleteUniqueOptionU256(const FDeleteUniqueOptionU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_256"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionU256() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU256); } + FORCEINLINE FDeleteUniqueOptionU256Args GetAsDeleteUniqueOptionU256() const + { + ensureMsgf(IsDeleteUniqueOptionU256(), TEXT("Reducer does not hold DeleteUniqueOptionU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU256!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU256Args(); + } + + static FReducer DeleteUniqueOptionU32(const FDeleteUniqueOptionU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_32"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionU32() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU32); } + FORCEINLINE FDeleteUniqueOptionU32Args GetAsDeleteUniqueOptionU32() const + { + ensureMsgf(IsDeleteUniqueOptionU32(), TEXT("Reducer does not hold DeleteUniqueOptionU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU32!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU32Args(); + } + + static FReducer DeleteUniqueOptionU64(const FDeleteUniqueOptionU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_64"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionU64() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU64); } + FORCEINLINE FDeleteUniqueOptionU64Args GetAsDeleteUniqueOptionU64() const + { + ensureMsgf(IsDeleteUniqueOptionU64(), TEXT("Reducer does not hold DeleteUniqueOptionU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU64!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU64Args(); + } + + static FReducer DeleteUniqueOptionU8(const FDeleteUniqueOptionU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_8"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionU8() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU8); } + FORCEINLINE FDeleteUniqueOptionU8Args GetAsDeleteUniqueOptionU8() const + { + ensureMsgf(IsDeleteUniqueOptionU8(), TEXT("Reducer does not hold DeleteUniqueOptionU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU8!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU8Args(); + } + + static FReducer DeleteUniqueOptionUuid(const FDeleteUniqueOptionUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_uuid"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionUuid() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionUuid); } + FORCEINLINE FDeleteUniqueOptionUuidArgs GetAsDeleteUniqueOptionUuid() const + { + ensureMsgf(IsDeleteUniqueOptionUuid(), TEXT("Reducer does not hold DeleteUniqueOptionUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionUuid!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionUuidArgs(); + } + + static FReducer DeleteUniqueString(const FDeleteUniqueStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_string"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueString() const { return Tag == static_cast(EReducerTag::DeleteUniqueString); } + FORCEINLINE FDeleteUniqueStringArgs GetAsDeleteUniqueString() const + { + ensureMsgf(IsDeleteUniqueString(), TEXT("Reducer does not hold DeleteUniqueString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueString!")); + return TypedData ? TypedData->Value : FDeleteUniqueStringArgs(); + } + + static FReducer DeleteUniqueU128(const FDeleteUniqueU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_128"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU128() const { return Tag == static_cast(EReducerTag::DeleteUniqueU128); } + FORCEINLINE FDeleteUniqueU128Args GetAsDeleteUniqueU128() const + { + ensureMsgf(IsDeleteUniqueU128(), TEXT("Reducer does not hold DeleteUniqueU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU128!")); + return TypedData ? TypedData->Value : FDeleteUniqueU128Args(); + } + + static FReducer DeleteUniqueU16(const FDeleteUniqueU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_16"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU16() const { return Tag == static_cast(EReducerTag::DeleteUniqueU16); } + FORCEINLINE FDeleteUniqueU16Args GetAsDeleteUniqueU16() const + { + ensureMsgf(IsDeleteUniqueU16(), TEXT("Reducer does not hold DeleteUniqueU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU16!")); + return TypedData ? TypedData->Value : FDeleteUniqueU16Args(); + } + + static FReducer DeleteUniqueU256(const FDeleteUniqueU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_256"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU256() const { return Tag == static_cast(EReducerTag::DeleteUniqueU256); } + FORCEINLINE FDeleteUniqueU256Args GetAsDeleteUniqueU256() const + { + ensureMsgf(IsDeleteUniqueU256(), TEXT("Reducer does not hold DeleteUniqueU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU256!")); + return TypedData ? TypedData->Value : FDeleteUniqueU256Args(); + } + + static FReducer DeleteUniqueU32(const FDeleteUniqueU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_32"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU32() const { return Tag == static_cast(EReducerTag::DeleteUniqueU32); } + FORCEINLINE FDeleteUniqueU32Args GetAsDeleteUniqueU32() const + { + ensureMsgf(IsDeleteUniqueU32(), TEXT("Reducer does not hold DeleteUniqueU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU32!")); + return TypedData ? TypedData->Value : FDeleteUniqueU32Args(); + } + + static FReducer DeleteUniqueU64(const FDeleteUniqueU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_64"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU64() const { return Tag == static_cast(EReducerTag::DeleteUniqueU64); } + FORCEINLINE FDeleteUniqueU64Args GetAsDeleteUniqueU64() const + { + ensureMsgf(IsDeleteUniqueU64(), TEXT("Reducer does not hold DeleteUniqueU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU64!")); + return TypedData ? TypedData->Value : FDeleteUniqueU64Args(); + } + + static FReducer DeleteUniqueU8(const FDeleteUniqueU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_8"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU8() const { return Tag == static_cast(EReducerTag::DeleteUniqueU8); } + FORCEINLINE FDeleteUniqueU8Args GetAsDeleteUniqueU8() const + { + ensureMsgf(IsDeleteUniqueU8(), TEXT("Reducer does not hold DeleteUniqueU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU8!")); + return TypedData ? TypedData->Value : FDeleteUniqueU8Args(); + } + + static FReducer DeleteUniqueUuid(const FDeleteUniqueUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_uuid"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueUuid() const { return Tag == static_cast(EReducerTag::DeleteUniqueUuid); } + FORCEINLINE FDeleteUniqueUuidArgs GetAsDeleteUniqueUuid() const + { + ensureMsgf(IsDeleteUniqueUuid(), TEXT("Reducer does not hold DeleteUniqueUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueUuid!")); + return TypedData ? TypedData->Value : FDeleteUniqueUuidArgs(); + } + + static FReducer InsertCallTimestamp(const FInsertCallTimestampArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertCallTimestamp); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_call_timestamp"); + return Out; + } + + FORCEINLINE bool IsInsertCallTimestamp() const { return Tag == static_cast(EReducerTag::InsertCallTimestamp); } + FORCEINLINE FInsertCallTimestampArgs GetAsInsertCallTimestamp() const + { + ensureMsgf(IsInsertCallTimestamp(), TEXT("Reducer does not hold InsertCallTimestamp!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallTimestamp!")); + return TypedData ? TypedData->Value : FInsertCallTimestampArgs(); + } + + static FReducer InsertCallUuidV4(const FInsertCallUuidV4Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertCallUuidV4); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_call_uuid_v_4"); + return Out; + } + + FORCEINLINE bool IsInsertCallUuidV4() const { return Tag == static_cast(EReducerTag::InsertCallUuidV4); } + FORCEINLINE FInsertCallUuidV4Args GetAsInsertCallUuidV4() const + { + ensureMsgf(IsInsertCallUuidV4(), TEXT("Reducer does not hold InsertCallUuidV4!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallUuidV4!")); + return TypedData ? TypedData->Value : FInsertCallUuidV4Args(); + } + + static FReducer InsertCallUuidV7(const FInsertCallUuidV7Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertCallUuidV7); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_call_uuid_v_7"); + return Out; + } + + FORCEINLINE bool IsInsertCallUuidV7() const { return Tag == static_cast(EReducerTag::InsertCallUuidV7); } + FORCEINLINE FInsertCallUuidV7Args GetAsInsertCallUuidV7() const + { + ensureMsgf(IsInsertCallUuidV7(), TEXT("Reducer does not hold InsertCallUuidV7!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallUuidV7!")); + return TypedData ? TypedData->Value : FInsertCallUuidV7Args(); + } + + static FReducer InsertCallerOneConnectionId(const FInsertCallerOneConnectionIdArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertCallerOneConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_caller_one_connection_id"); + return Out; + } + + FORCEINLINE bool IsInsertCallerOneConnectionId() const { return Tag == static_cast(EReducerTag::InsertCallerOneConnectionId); } + FORCEINLINE FInsertCallerOneConnectionIdArgs GetAsInsertCallerOneConnectionId() const + { + ensureMsgf(IsInsertCallerOneConnectionId(), TEXT("Reducer does not hold InsertCallerOneConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallerOneConnectionId!")); + return TypedData ? TypedData->Value : FInsertCallerOneConnectionIdArgs(); } static FReducer InsertCallerOneIdentity(const FInsertCallerOneIdentityArgs& Value) @@ -4787,6 +5582,312 @@ struct TESTCLIENT_API FReducer return TypedData ? TypedData->Value : FInsertUniqueIdentityArgs(); } + static FReducer InsertUniqueOptionBool(const FInsertUniqueOptionBoolArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionBool); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_bool"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionBool() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionBool); } + FORCEINLINE FInsertUniqueOptionBoolArgs GetAsInsertUniqueOptionBool() const + { + ensureMsgf(IsInsertUniqueOptionBool(), TEXT("Reducer does not hold InsertUniqueOptionBool!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionBool!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionBoolArgs(); + } + + static FReducer InsertUniqueOptionConnectionId(const FInsertUniqueOptionConnectionIdArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_connection_id"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionConnectionId() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionConnectionId); } + FORCEINLINE FInsertUniqueOptionConnectionIdArgs GetAsInsertUniqueOptionConnectionId() const + { + ensureMsgf(IsInsertUniqueOptionConnectionId(), TEXT("Reducer does not hold InsertUniqueOptionConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionConnectionId!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionConnectionIdArgs(); + } + + static FReducer InsertUniqueOptionI128(const FInsertUniqueOptionI128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_128"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI128() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI128); } + FORCEINLINE FInsertUniqueOptionI128Args GetAsInsertUniqueOptionI128() const + { + ensureMsgf(IsInsertUniqueOptionI128(), TEXT("Reducer does not hold InsertUniqueOptionI128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI128!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI128Args(); + } + + static FReducer InsertUniqueOptionI16(const FInsertUniqueOptionI16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_16"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI16() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI16); } + FORCEINLINE FInsertUniqueOptionI16Args GetAsInsertUniqueOptionI16() const + { + ensureMsgf(IsInsertUniqueOptionI16(), TEXT("Reducer does not hold InsertUniqueOptionI16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI16!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI16Args(); + } + + static FReducer InsertUniqueOptionI256(const FInsertUniqueOptionI256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_256"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI256() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI256); } + FORCEINLINE FInsertUniqueOptionI256Args GetAsInsertUniqueOptionI256() const + { + ensureMsgf(IsInsertUniqueOptionI256(), TEXT("Reducer does not hold InsertUniqueOptionI256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI256!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI256Args(); + } + + static FReducer InsertUniqueOptionI32(const FInsertUniqueOptionI32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_32"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI32() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI32); } + FORCEINLINE FInsertUniqueOptionI32Args GetAsInsertUniqueOptionI32() const + { + ensureMsgf(IsInsertUniqueOptionI32(), TEXT("Reducer does not hold InsertUniqueOptionI32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI32!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI32Args(); + } + + static FReducer InsertUniqueOptionI64(const FInsertUniqueOptionI64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_64"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI64() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI64); } + FORCEINLINE FInsertUniqueOptionI64Args GetAsInsertUniqueOptionI64() const + { + ensureMsgf(IsInsertUniqueOptionI64(), TEXT("Reducer does not hold InsertUniqueOptionI64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI64!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI64Args(); + } + + static FReducer InsertUniqueOptionI8(const FInsertUniqueOptionI8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_8"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI8() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI8); } + FORCEINLINE FInsertUniqueOptionI8Args GetAsInsertUniqueOptionI8() const + { + ensureMsgf(IsInsertUniqueOptionI8(), TEXT("Reducer does not hold InsertUniqueOptionI8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI8!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI8Args(); + } + + static FReducer InsertUniqueOptionIdentity(const FInsertUniqueOptionIdentityArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionIdentity); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_identity"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionIdentity() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionIdentity); } + FORCEINLINE FInsertUniqueOptionIdentityArgs GetAsInsertUniqueOptionIdentity() const + { + ensureMsgf(IsInsertUniqueOptionIdentity(), TEXT("Reducer does not hold InsertUniqueOptionIdentity!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionIdentity!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionIdentityArgs(); + } + + static FReducer InsertUniqueOptionString(const FInsertUniqueOptionStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_string"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionString() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionString); } + FORCEINLINE FInsertUniqueOptionStringArgs GetAsInsertUniqueOptionString() const + { + ensureMsgf(IsInsertUniqueOptionString(), TEXT("Reducer does not hold InsertUniqueOptionString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionString!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionStringArgs(); + } + + static FReducer InsertUniqueOptionU128(const FInsertUniqueOptionU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_128"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU128() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU128); } + FORCEINLINE FInsertUniqueOptionU128Args GetAsInsertUniqueOptionU128() const + { + ensureMsgf(IsInsertUniqueOptionU128(), TEXT("Reducer does not hold InsertUniqueOptionU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU128!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU128Args(); + } + + static FReducer InsertUniqueOptionU16(const FInsertUniqueOptionU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_16"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU16() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU16); } + FORCEINLINE FInsertUniqueOptionU16Args GetAsInsertUniqueOptionU16() const + { + ensureMsgf(IsInsertUniqueOptionU16(), TEXT("Reducer does not hold InsertUniqueOptionU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU16!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU16Args(); + } + + static FReducer InsertUniqueOptionU256(const FInsertUniqueOptionU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_256"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU256() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU256); } + FORCEINLINE FInsertUniqueOptionU256Args GetAsInsertUniqueOptionU256() const + { + ensureMsgf(IsInsertUniqueOptionU256(), TEXT("Reducer does not hold InsertUniqueOptionU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU256!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU256Args(); + } + + static FReducer InsertUniqueOptionU32(const FInsertUniqueOptionU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_32"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU32() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU32); } + FORCEINLINE FInsertUniqueOptionU32Args GetAsInsertUniqueOptionU32() const + { + ensureMsgf(IsInsertUniqueOptionU32(), TEXT("Reducer does not hold InsertUniqueOptionU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU32!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU32Args(); + } + + static FReducer InsertUniqueOptionU64(const FInsertUniqueOptionU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_64"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU64() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU64); } + FORCEINLINE FInsertUniqueOptionU64Args GetAsInsertUniqueOptionU64() const + { + ensureMsgf(IsInsertUniqueOptionU64(), TEXT("Reducer does not hold InsertUniqueOptionU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU64!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU64Args(); + } + + static FReducer InsertUniqueOptionU8(const FInsertUniqueOptionU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_8"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU8() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU8); } + FORCEINLINE FInsertUniqueOptionU8Args GetAsInsertUniqueOptionU8() const + { + ensureMsgf(IsInsertUniqueOptionU8(), TEXT("Reducer does not hold InsertUniqueOptionU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU8!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU8Args(); + } + + static FReducer InsertUniqueOptionUuid(const FInsertUniqueOptionUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_uuid"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionUuid() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionUuid); } + FORCEINLINE FInsertUniqueOptionUuidArgs GetAsInsertUniqueOptionUuid() const + { + ensureMsgf(IsInsertUniqueOptionUuid(), TEXT("Reducer does not hold InsertUniqueOptionUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionUuid!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionUuidArgs(); + } + static FReducer InsertUniqueString(const FInsertUniqueStringArgs& Value) { FReducer Out; @@ -5993,191 +7094,497 @@ struct TESTCLIENT_API FReducer return TypedData ? TypedData->Value : FUpdateUniqueIdentityArgs(); } - static FReducer UpdateUniqueString(const FUpdateUniqueStringArgs& Value) + static FReducer UpdateUniqueOptionBool(const FUpdateUniqueOptionBoolArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueString); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_string"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionBool); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_bool"); return Out; } - FORCEINLINE bool IsUpdateUniqueString() const { return Tag == static_cast(EReducerTag::UpdateUniqueString); } - FORCEINLINE FUpdateUniqueStringArgs GetAsUpdateUniqueString() const + FORCEINLINE bool IsUpdateUniqueOptionBool() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionBool); } + FORCEINLINE FUpdateUniqueOptionBoolArgs GetAsUpdateUniqueOptionBool() const { - ensureMsgf(IsUpdateUniqueString(), TEXT("Reducer does not hold UpdateUniqueString!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueString!")); - return TypedData ? TypedData->Value : FUpdateUniqueStringArgs(); + ensureMsgf(IsUpdateUniqueOptionBool(), TEXT("Reducer does not hold UpdateUniqueOptionBool!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionBool!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionBoolArgs(); } - static FReducer UpdateUniqueU128(const FUpdateUniqueU128Args& Value) + static FReducer UpdateUniqueOptionConnectionId(const FUpdateUniqueOptionConnectionIdArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU128); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_128"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_connection_id"); return Out; } - FORCEINLINE bool IsUpdateUniqueU128() const { return Tag == static_cast(EReducerTag::UpdateUniqueU128); } - FORCEINLINE FUpdateUniqueU128Args GetAsUpdateUniqueU128() const + FORCEINLINE bool IsUpdateUniqueOptionConnectionId() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionConnectionId); } + FORCEINLINE FUpdateUniqueOptionConnectionIdArgs GetAsUpdateUniqueOptionConnectionId() const { - ensureMsgf(IsUpdateUniqueU128(), TEXT("Reducer does not hold UpdateUniqueU128!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU128!")); - return TypedData ? TypedData->Value : FUpdateUniqueU128Args(); + ensureMsgf(IsUpdateUniqueOptionConnectionId(), TEXT("Reducer does not hold UpdateUniqueOptionConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionConnectionId!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionConnectionIdArgs(); } - static FReducer UpdateUniqueU16(const FUpdateUniqueU16Args& Value) + static FReducer UpdateUniqueOptionI128(const FUpdateUniqueOptionI128Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU16); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_16"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_128"); return Out; } - FORCEINLINE bool IsUpdateUniqueU16() const { return Tag == static_cast(EReducerTag::UpdateUniqueU16); } - FORCEINLINE FUpdateUniqueU16Args GetAsUpdateUniqueU16() const + FORCEINLINE bool IsUpdateUniqueOptionI128() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI128); } + FORCEINLINE FUpdateUniqueOptionI128Args GetAsUpdateUniqueOptionI128() const { - ensureMsgf(IsUpdateUniqueU16(), TEXT("Reducer does not hold UpdateUniqueU16!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU16!")); - return TypedData ? TypedData->Value : FUpdateUniqueU16Args(); + ensureMsgf(IsUpdateUniqueOptionI128(), TEXT("Reducer does not hold UpdateUniqueOptionI128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI128!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI128Args(); } - static FReducer UpdateUniqueU256(const FUpdateUniqueU256Args& Value) + static FReducer UpdateUniqueOptionI16(const FUpdateUniqueOptionI16Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU256); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_256"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_16"); return Out; } - FORCEINLINE bool IsUpdateUniqueU256() const { return Tag == static_cast(EReducerTag::UpdateUniqueU256); } - FORCEINLINE FUpdateUniqueU256Args GetAsUpdateUniqueU256() const + FORCEINLINE bool IsUpdateUniqueOptionI16() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI16); } + FORCEINLINE FUpdateUniqueOptionI16Args GetAsUpdateUniqueOptionI16() const { - ensureMsgf(IsUpdateUniqueU256(), TEXT("Reducer does not hold UpdateUniqueU256!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU256!")); - return TypedData ? TypedData->Value : FUpdateUniqueU256Args(); + ensureMsgf(IsUpdateUniqueOptionI16(), TEXT("Reducer does not hold UpdateUniqueOptionI16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI16!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI16Args(); } - static FReducer UpdateUniqueU32(const FUpdateUniqueU32Args& Value) + static FReducer UpdateUniqueOptionI256(const FUpdateUniqueOptionI256Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU32); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_32"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_256"); return Out; } - FORCEINLINE bool IsUpdateUniqueU32() const { return Tag == static_cast(EReducerTag::UpdateUniqueU32); } - FORCEINLINE FUpdateUniqueU32Args GetAsUpdateUniqueU32() const + FORCEINLINE bool IsUpdateUniqueOptionI256() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI256); } + FORCEINLINE FUpdateUniqueOptionI256Args GetAsUpdateUniqueOptionI256() const { - ensureMsgf(IsUpdateUniqueU32(), TEXT("Reducer does not hold UpdateUniqueU32!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU32!")); - return TypedData ? TypedData->Value : FUpdateUniqueU32Args(); + ensureMsgf(IsUpdateUniqueOptionI256(), TEXT("Reducer does not hold UpdateUniqueOptionI256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI256!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI256Args(); } - static FReducer UpdateUniqueU64(const FUpdateUniqueU64Args& Value) + static FReducer UpdateUniqueOptionI32(const FUpdateUniqueOptionI32Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU64); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_64"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_32"); return Out; } - FORCEINLINE bool IsUpdateUniqueU64() const { return Tag == static_cast(EReducerTag::UpdateUniqueU64); } - FORCEINLINE FUpdateUniqueU64Args GetAsUpdateUniqueU64() const + FORCEINLINE bool IsUpdateUniqueOptionI32() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI32); } + FORCEINLINE FUpdateUniqueOptionI32Args GetAsUpdateUniqueOptionI32() const { - ensureMsgf(IsUpdateUniqueU64(), TEXT("Reducer does not hold UpdateUniqueU64!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU64!")); - return TypedData ? TypedData->Value : FUpdateUniqueU64Args(); + ensureMsgf(IsUpdateUniqueOptionI32(), TEXT("Reducer does not hold UpdateUniqueOptionI32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI32!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI32Args(); } - static FReducer UpdateUniqueU8(const FUpdateUniqueU8Args& Value) + static FReducer UpdateUniqueOptionI64(const FUpdateUniqueOptionI64Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU8); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_8"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_64"); return Out; } - FORCEINLINE bool IsUpdateUniqueU8() const { return Tag == static_cast(EReducerTag::UpdateUniqueU8); } - FORCEINLINE FUpdateUniqueU8Args GetAsUpdateUniqueU8() const + FORCEINLINE bool IsUpdateUniqueOptionI64() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI64); } + FORCEINLINE FUpdateUniqueOptionI64Args GetAsUpdateUniqueOptionI64() const { - ensureMsgf(IsUpdateUniqueU8(), TEXT("Reducer does not hold UpdateUniqueU8!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU8!")); - return TypedData ? TypedData->Value : FUpdateUniqueU8Args(); + ensureMsgf(IsUpdateUniqueOptionI64(), TEXT("Reducer does not hold UpdateUniqueOptionI64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI64!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI64Args(); } - static FReducer UpdateUniqueUuid(const FUpdateUniqueUuidArgs& Value) + static FReducer UpdateUniqueOptionI8(const FUpdateUniqueOptionI8Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueUuid); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_uuid"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_8"); return Out; } - FORCEINLINE bool IsUpdateUniqueUuid() const { return Tag == static_cast(EReducerTag::UpdateUniqueUuid); } - FORCEINLINE FUpdateUniqueUuidArgs GetAsUpdateUniqueUuid() const + FORCEINLINE bool IsUpdateUniqueOptionI8() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI8); } + FORCEINLINE FUpdateUniqueOptionI8Args GetAsUpdateUniqueOptionI8() const { - ensureMsgf(IsUpdateUniqueUuid(), TEXT("Reducer does not hold UpdateUniqueUuid!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueUuid!")); - return TypedData ? TypedData->Value : FUpdateUniqueUuidArgs(); + ensureMsgf(IsUpdateUniqueOptionI8(), TEXT("Reducer does not hold UpdateUniqueOptionI8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI8!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI8Args(); } - FORCEINLINE bool operator==(const FReducer& Other) const + static FReducer UpdateUniqueOptionIdentity(const FUpdateUniqueOptionIdentityArgs& Value) { - if (Tag != Other.Tag || ReducerId != Other.ReducerId || RequestId != Other.RequestId || ReducerName != Other.ReducerName) return false; - switch (Tag) - { - case static_cast(EReducerTag::DeleteAllOneBool): - return GetAsDeleteAllOneBool() == Other.GetAsDeleteAllOneBool(); - case static_cast(EReducerTag::DeleteAllOneByteStruct): - return GetAsDeleteAllOneByteStruct() == Other.GetAsDeleteAllOneByteStruct(); - case static_cast(EReducerTag::DeleteAllOneEnumWithPayload): - return GetAsDeleteAllOneEnumWithPayload() == Other.GetAsDeleteAllOneEnumWithPayload(); - case static_cast(EReducerTag::DeleteAllOneEveryPrimitiveStruct): - return GetAsDeleteAllOneEveryPrimitiveStruct() == Other.GetAsDeleteAllOneEveryPrimitiveStruct(); - case static_cast(EReducerTag::DeleteAllOneEveryVecStruct): - return GetAsDeleteAllOneEveryVecStruct() == Other.GetAsDeleteAllOneEveryVecStruct(); - case static_cast(EReducerTag::DeleteAllOneF32): - return GetAsDeleteAllOneF32() == Other.GetAsDeleteAllOneF32(); - case static_cast(EReducerTag::DeleteAllOneF64): - return GetAsDeleteAllOneF64() == Other.GetAsDeleteAllOneF64(); - case static_cast(EReducerTag::DeleteAllOneI128): - return GetAsDeleteAllOneI128() == Other.GetAsDeleteAllOneI128(); - case static_cast(EReducerTag::DeleteAllOneI16): - return GetAsDeleteAllOneI16() == Other.GetAsDeleteAllOneI16(); - case static_cast(EReducerTag::DeleteAllOneI256): - return GetAsDeleteAllOneI256() == Other.GetAsDeleteAllOneI256(); - case static_cast(EReducerTag::DeleteAllOneI32): - return GetAsDeleteAllOneI32() == Other.GetAsDeleteAllOneI32(); - case static_cast(EReducerTag::DeleteAllOneI64): - return GetAsDeleteAllOneI64() == Other.GetAsDeleteAllOneI64(); - case static_cast(EReducerTag::DeleteAllOneI8): - return GetAsDeleteAllOneI8() == Other.GetAsDeleteAllOneI8(); - case static_cast(EReducerTag::DeleteAllOneIdentity): - return GetAsDeleteAllOneIdentity() == Other.GetAsDeleteAllOneIdentity(); - case static_cast(EReducerTag::DeleteAllOneSimpleEnum): - return GetAsDeleteAllOneSimpleEnum() == Other.GetAsDeleteAllOneSimpleEnum(); - case static_cast(EReducerTag::DeleteAllOneString): - return GetAsDeleteAllOneString() == Other.GetAsDeleteAllOneString(); - case static_cast(EReducerTag::DeleteAllOneTimestamp): - return GetAsDeleteAllOneTimestamp() == Other.GetAsDeleteAllOneTimestamp(); - case static_cast(EReducerTag::DeleteAllOneU128): - return GetAsDeleteAllOneU128() == Other.GetAsDeleteAllOneU128(); + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionIdentity); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_identity"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionIdentity() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionIdentity); } + FORCEINLINE FUpdateUniqueOptionIdentityArgs GetAsUpdateUniqueOptionIdentity() const + { + ensureMsgf(IsUpdateUniqueOptionIdentity(), TEXT("Reducer does not hold UpdateUniqueOptionIdentity!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionIdentity!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionIdentityArgs(); + } + + static FReducer UpdateUniqueOptionString(const FUpdateUniqueOptionStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_string"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionString() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionString); } + FORCEINLINE FUpdateUniqueOptionStringArgs GetAsUpdateUniqueOptionString() const + { + ensureMsgf(IsUpdateUniqueOptionString(), TEXT("Reducer does not hold UpdateUniqueOptionString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionString!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionStringArgs(); + } + + static FReducer UpdateUniqueOptionU128(const FUpdateUniqueOptionU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_128"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU128() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU128); } + FORCEINLINE FUpdateUniqueOptionU128Args GetAsUpdateUniqueOptionU128() const + { + ensureMsgf(IsUpdateUniqueOptionU128(), TEXT("Reducer does not hold UpdateUniqueOptionU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU128!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU128Args(); + } + + static FReducer UpdateUniqueOptionU16(const FUpdateUniqueOptionU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_16"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU16() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU16); } + FORCEINLINE FUpdateUniqueOptionU16Args GetAsUpdateUniqueOptionU16() const + { + ensureMsgf(IsUpdateUniqueOptionU16(), TEXT("Reducer does not hold UpdateUniqueOptionU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU16!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU16Args(); + } + + static FReducer UpdateUniqueOptionU256(const FUpdateUniqueOptionU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_256"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU256() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU256); } + FORCEINLINE FUpdateUniqueOptionU256Args GetAsUpdateUniqueOptionU256() const + { + ensureMsgf(IsUpdateUniqueOptionU256(), TEXT("Reducer does not hold UpdateUniqueOptionU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU256!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU256Args(); + } + + static FReducer UpdateUniqueOptionU32(const FUpdateUniqueOptionU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_32"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU32() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU32); } + FORCEINLINE FUpdateUniqueOptionU32Args GetAsUpdateUniqueOptionU32() const + { + ensureMsgf(IsUpdateUniqueOptionU32(), TEXT("Reducer does not hold UpdateUniqueOptionU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU32!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU32Args(); + } + + static FReducer UpdateUniqueOptionU64(const FUpdateUniqueOptionU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_64"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU64() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU64); } + FORCEINLINE FUpdateUniqueOptionU64Args GetAsUpdateUniqueOptionU64() const + { + ensureMsgf(IsUpdateUniqueOptionU64(), TEXT("Reducer does not hold UpdateUniqueOptionU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU64!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU64Args(); + } + + static FReducer UpdateUniqueOptionU8(const FUpdateUniqueOptionU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_8"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU8() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU8); } + FORCEINLINE FUpdateUniqueOptionU8Args GetAsUpdateUniqueOptionU8() const + { + ensureMsgf(IsUpdateUniqueOptionU8(), TEXT("Reducer does not hold UpdateUniqueOptionU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU8!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU8Args(); + } + + static FReducer UpdateUniqueOptionUuid(const FUpdateUniqueOptionUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_uuid"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionUuid() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionUuid); } + FORCEINLINE FUpdateUniqueOptionUuidArgs GetAsUpdateUniqueOptionUuid() const + { + ensureMsgf(IsUpdateUniqueOptionUuid(), TEXT("Reducer does not hold UpdateUniqueOptionUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionUuid!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionUuidArgs(); + } + + static FReducer UpdateUniqueString(const FUpdateUniqueStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_string"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueString() const { return Tag == static_cast(EReducerTag::UpdateUniqueString); } + FORCEINLINE FUpdateUniqueStringArgs GetAsUpdateUniqueString() const + { + ensureMsgf(IsUpdateUniqueString(), TEXT("Reducer does not hold UpdateUniqueString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueString!")); + return TypedData ? TypedData->Value : FUpdateUniqueStringArgs(); + } + + static FReducer UpdateUniqueU128(const FUpdateUniqueU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_128"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU128() const { return Tag == static_cast(EReducerTag::UpdateUniqueU128); } + FORCEINLINE FUpdateUniqueU128Args GetAsUpdateUniqueU128() const + { + ensureMsgf(IsUpdateUniqueU128(), TEXT("Reducer does not hold UpdateUniqueU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU128!")); + return TypedData ? TypedData->Value : FUpdateUniqueU128Args(); + } + + static FReducer UpdateUniqueU16(const FUpdateUniqueU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_16"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU16() const { return Tag == static_cast(EReducerTag::UpdateUniqueU16); } + FORCEINLINE FUpdateUniqueU16Args GetAsUpdateUniqueU16() const + { + ensureMsgf(IsUpdateUniqueU16(), TEXT("Reducer does not hold UpdateUniqueU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU16!")); + return TypedData ? TypedData->Value : FUpdateUniqueU16Args(); + } + + static FReducer UpdateUniqueU256(const FUpdateUniqueU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_256"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU256() const { return Tag == static_cast(EReducerTag::UpdateUniqueU256); } + FORCEINLINE FUpdateUniqueU256Args GetAsUpdateUniqueU256() const + { + ensureMsgf(IsUpdateUniqueU256(), TEXT("Reducer does not hold UpdateUniqueU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU256!")); + return TypedData ? TypedData->Value : FUpdateUniqueU256Args(); + } + + static FReducer UpdateUniqueU32(const FUpdateUniqueU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_32"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU32() const { return Tag == static_cast(EReducerTag::UpdateUniqueU32); } + FORCEINLINE FUpdateUniqueU32Args GetAsUpdateUniqueU32() const + { + ensureMsgf(IsUpdateUniqueU32(), TEXT("Reducer does not hold UpdateUniqueU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU32!")); + return TypedData ? TypedData->Value : FUpdateUniqueU32Args(); + } + + static FReducer UpdateUniqueU64(const FUpdateUniqueU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_64"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU64() const { return Tag == static_cast(EReducerTag::UpdateUniqueU64); } + FORCEINLINE FUpdateUniqueU64Args GetAsUpdateUniqueU64() const + { + ensureMsgf(IsUpdateUniqueU64(), TEXT("Reducer does not hold UpdateUniqueU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU64!")); + return TypedData ? TypedData->Value : FUpdateUniqueU64Args(); + } + + static FReducer UpdateUniqueU8(const FUpdateUniqueU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_8"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU8() const { return Tag == static_cast(EReducerTag::UpdateUniqueU8); } + FORCEINLINE FUpdateUniqueU8Args GetAsUpdateUniqueU8() const + { + ensureMsgf(IsUpdateUniqueU8(), TEXT("Reducer does not hold UpdateUniqueU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU8!")); + return TypedData ? TypedData->Value : FUpdateUniqueU8Args(); + } + + static FReducer UpdateUniqueUuid(const FUpdateUniqueUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_uuid"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueUuid() const { return Tag == static_cast(EReducerTag::UpdateUniqueUuid); } + FORCEINLINE FUpdateUniqueUuidArgs GetAsUpdateUniqueUuid() const + { + ensureMsgf(IsUpdateUniqueUuid(), TEXT("Reducer does not hold UpdateUniqueUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueUuid!")); + return TypedData ? TypedData->Value : FUpdateUniqueUuidArgs(); + } + + FORCEINLINE bool operator==(const FReducer& Other) const + { + if (Tag != Other.Tag || ReducerId != Other.ReducerId || RequestId != Other.RequestId || ReducerName != Other.ReducerName) return false; + switch (Tag) + { + case static_cast(EReducerTag::DeleteAllOneBool): + return GetAsDeleteAllOneBool() == Other.GetAsDeleteAllOneBool(); + case static_cast(EReducerTag::DeleteAllOneByteStruct): + return GetAsDeleteAllOneByteStruct() == Other.GetAsDeleteAllOneByteStruct(); + case static_cast(EReducerTag::DeleteAllOneEnumWithPayload): + return GetAsDeleteAllOneEnumWithPayload() == Other.GetAsDeleteAllOneEnumWithPayload(); + case static_cast(EReducerTag::DeleteAllOneEveryPrimitiveStruct): + return GetAsDeleteAllOneEveryPrimitiveStruct() == Other.GetAsDeleteAllOneEveryPrimitiveStruct(); + case static_cast(EReducerTag::DeleteAllOneEveryVecStruct): + return GetAsDeleteAllOneEveryVecStruct() == Other.GetAsDeleteAllOneEveryVecStruct(); + case static_cast(EReducerTag::DeleteAllOneF32): + return GetAsDeleteAllOneF32() == Other.GetAsDeleteAllOneF32(); + case static_cast(EReducerTag::DeleteAllOneF64): + return GetAsDeleteAllOneF64() == Other.GetAsDeleteAllOneF64(); + case static_cast(EReducerTag::DeleteAllOneI128): + return GetAsDeleteAllOneI128() == Other.GetAsDeleteAllOneI128(); + case static_cast(EReducerTag::DeleteAllOneI16): + return GetAsDeleteAllOneI16() == Other.GetAsDeleteAllOneI16(); + case static_cast(EReducerTag::DeleteAllOneI256): + return GetAsDeleteAllOneI256() == Other.GetAsDeleteAllOneI256(); + case static_cast(EReducerTag::DeleteAllOneI32): + return GetAsDeleteAllOneI32() == Other.GetAsDeleteAllOneI32(); + case static_cast(EReducerTag::DeleteAllOneI64): + return GetAsDeleteAllOneI64() == Other.GetAsDeleteAllOneI64(); + case static_cast(EReducerTag::DeleteAllOneI8): + return GetAsDeleteAllOneI8() == Other.GetAsDeleteAllOneI8(); + case static_cast(EReducerTag::DeleteAllOneIdentity): + return GetAsDeleteAllOneIdentity() == Other.GetAsDeleteAllOneIdentity(); + case static_cast(EReducerTag::DeleteAllOneSimpleEnum): + return GetAsDeleteAllOneSimpleEnum() == Other.GetAsDeleteAllOneSimpleEnum(); + case static_cast(EReducerTag::DeleteAllOneString): + return GetAsDeleteAllOneString() == Other.GetAsDeleteAllOneString(); + case static_cast(EReducerTag::DeleteAllOneTimestamp): + return GetAsDeleteAllOneTimestamp() == Other.GetAsDeleteAllOneTimestamp(); + case static_cast(EReducerTag::DeleteAllOneU128): + return GetAsDeleteAllOneU128() == Other.GetAsDeleteAllOneU128(); case static_cast(EReducerTag::DeleteAllOneU16): return GetAsDeleteAllOneU16() == Other.GetAsDeleteAllOneU16(); case static_cast(EReducerTag::DeleteAllOneU256): @@ -6260,6 +7667,40 @@ struct TESTCLIENT_API FReducer return GetAsDeleteAllUniqueI8() == Other.GetAsDeleteAllUniqueI8(); case static_cast(EReducerTag::DeleteAllUniqueIdentity): return GetAsDeleteAllUniqueIdentity() == Other.GetAsDeleteAllUniqueIdentity(); + case static_cast(EReducerTag::DeleteAllUniqueOptionBool): + return GetAsDeleteAllUniqueOptionBool() == Other.GetAsDeleteAllUniqueOptionBool(); + case static_cast(EReducerTag::DeleteAllUniqueOptionConnectionId): + return GetAsDeleteAllUniqueOptionConnectionId() == Other.GetAsDeleteAllUniqueOptionConnectionId(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI128): + return GetAsDeleteAllUniqueOptionI128() == Other.GetAsDeleteAllUniqueOptionI128(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI16): + return GetAsDeleteAllUniqueOptionI16() == Other.GetAsDeleteAllUniqueOptionI16(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI256): + return GetAsDeleteAllUniqueOptionI256() == Other.GetAsDeleteAllUniqueOptionI256(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI32): + return GetAsDeleteAllUniqueOptionI32() == Other.GetAsDeleteAllUniqueOptionI32(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI64): + return GetAsDeleteAllUniqueOptionI64() == Other.GetAsDeleteAllUniqueOptionI64(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI8): + return GetAsDeleteAllUniqueOptionI8() == Other.GetAsDeleteAllUniqueOptionI8(); + case static_cast(EReducerTag::DeleteAllUniqueOptionIdentity): + return GetAsDeleteAllUniqueOptionIdentity() == Other.GetAsDeleteAllUniqueOptionIdentity(); + case static_cast(EReducerTag::DeleteAllUniqueOptionString): + return GetAsDeleteAllUniqueOptionString() == Other.GetAsDeleteAllUniqueOptionString(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU128): + return GetAsDeleteAllUniqueOptionU128() == Other.GetAsDeleteAllUniqueOptionU128(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU16): + return GetAsDeleteAllUniqueOptionU16() == Other.GetAsDeleteAllUniqueOptionU16(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU256): + return GetAsDeleteAllUniqueOptionU256() == Other.GetAsDeleteAllUniqueOptionU256(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU32): + return GetAsDeleteAllUniqueOptionU32() == Other.GetAsDeleteAllUniqueOptionU32(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU64): + return GetAsDeleteAllUniqueOptionU64() == Other.GetAsDeleteAllUniqueOptionU64(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU8): + return GetAsDeleteAllUniqueOptionU8() == Other.GetAsDeleteAllUniqueOptionU8(); + case static_cast(EReducerTag::DeleteAllUniqueOptionUuid): + return GetAsDeleteAllUniqueOptionUuid() == Other.GetAsDeleteAllUniqueOptionUuid(); case static_cast(EReducerTag::DeleteAllUniqueString): return GetAsDeleteAllUniqueString() == Other.GetAsDeleteAllUniqueString(); case static_cast(EReducerTag::DeleteAllUniqueU128): @@ -6386,6 +7827,40 @@ struct TESTCLIENT_API FReducer return GetAsDeleteUniqueI8() == Other.GetAsDeleteUniqueI8(); case static_cast(EReducerTag::DeleteUniqueIdentity): return GetAsDeleteUniqueIdentity() == Other.GetAsDeleteUniqueIdentity(); + case static_cast(EReducerTag::DeleteUniqueOptionBool): + return GetAsDeleteUniqueOptionBool() == Other.GetAsDeleteUniqueOptionBool(); + case static_cast(EReducerTag::DeleteUniqueOptionConnectionId): + return GetAsDeleteUniqueOptionConnectionId() == Other.GetAsDeleteUniqueOptionConnectionId(); + case static_cast(EReducerTag::DeleteUniqueOptionI128): + return GetAsDeleteUniqueOptionI128() == Other.GetAsDeleteUniqueOptionI128(); + case static_cast(EReducerTag::DeleteUniqueOptionI16): + return GetAsDeleteUniqueOptionI16() == Other.GetAsDeleteUniqueOptionI16(); + case static_cast(EReducerTag::DeleteUniqueOptionI256): + return GetAsDeleteUniqueOptionI256() == Other.GetAsDeleteUniqueOptionI256(); + case static_cast(EReducerTag::DeleteUniqueOptionI32): + return GetAsDeleteUniqueOptionI32() == Other.GetAsDeleteUniqueOptionI32(); + case static_cast(EReducerTag::DeleteUniqueOptionI64): + return GetAsDeleteUniqueOptionI64() == Other.GetAsDeleteUniqueOptionI64(); + case static_cast(EReducerTag::DeleteUniqueOptionI8): + return GetAsDeleteUniqueOptionI8() == Other.GetAsDeleteUniqueOptionI8(); + case static_cast(EReducerTag::DeleteUniqueOptionIdentity): + return GetAsDeleteUniqueOptionIdentity() == Other.GetAsDeleteUniqueOptionIdentity(); + case static_cast(EReducerTag::DeleteUniqueOptionString): + return GetAsDeleteUniqueOptionString() == Other.GetAsDeleteUniqueOptionString(); + case static_cast(EReducerTag::DeleteUniqueOptionU128): + return GetAsDeleteUniqueOptionU128() == Other.GetAsDeleteUniqueOptionU128(); + case static_cast(EReducerTag::DeleteUniqueOptionU16): + return GetAsDeleteUniqueOptionU16() == Other.GetAsDeleteUniqueOptionU16(); + case static_cast(EReducerTag::DeleteUniqueOptionU256): + return GetAsDeleteUniqueOptionU256() == Other.GetAsDeleteUniqueOptionU256(); + case static_cast(EReducerTag::DeleteUniqueOptionU32): + return GetAsDeleteUniqueOptionU32() == Other.GetAsDeleteUniqueOptionU32(); + case static_cast(EReducerTag::DeleteUniqueOptionU64): + return GetAsDeleteUniqueOptionU64() == Other.GetAsDeleteUniqueOptionU64(); + case static_cast(EReducerTag::DeleteUniqueOptionU8): + return GetAsDeleteUniqueOptionU8() == Other.GetAsDeleteUniqueOptionU8(); + case static_cast(EReducerTag::DeleteUniqueOptionUuid): + return GetAsDeleteUniqueOptionUuid() == Other.GetAsDeleteUniqueOptionUuid(); case static_cast(EReducerTag::DeleteUniqueString): return GetAsDeleteUniqueString() == Other.GetAsDeleteUniqueString(); case static_cast(EReducerTag::DeleteUniqueU128): @@ -6570,6 +8045,40 @@ struct TESTCLIENT_API FReducer return GetAsInsertUniqueI8() == Other.GetAsInsertUniqueI8(); case static_cast(EReducerTag::InsertUniqueIdentity): return GetAsInsertUniqueIdentity() == Other.GetAsInsertUniqueIdentity(); + case static_cast(EReducerTag::InsertUniqueOptionBool): + return GetAsInsertUniqueOptionBool() == Other.GetAsInsertUniqueOptionBool(); + case static_cast(EReducerTag::InsertUniqueOptionConnectionId): + return GetAsInsertUniqueOptionConnectionId() == Other.GetAsInsertUniqueOptionConnectionId(); + case static_cast(EReducerTag::InsertUniqueOptionI128): + return GetAsInsertUniqueOptionI128() == Other.GetAsInsertUniqueOptionI128(); + case static_cast(EReducerTag::InsertUniqueOptionI16): + return GetAsInsertUniqueOptionI16() == Other.GetAsInsertUniqueOptionI16(); + case static_cast(EReducerTag::InsertUniqueOptionI256): + return GetAsInsertUniqueOptionI256() == Other.GetAsInsertUniqueOptionI256(); + case static_cast(EReducerTag::InsertUniqueOptionI32): + return GetAsInsertUniqueOptionI32() == Other.GetAsInsertUniqueOptionI32(); + case static_cast(EReducerTag::InsertUniqueOptionI64): + return GetAsInsertUniqueOptionI64() == Other.GetAsInsertUniqueOptionI64(); + case static_cast(EReducerTag::InsertUniqueOptionI8): + return GetAsInsertUniqueOptionI8() == Other.GetAsInsertUniqueOptionI8(); + case static_cast(EReducerTag::InsertUniqueOptionIdentity): + return GetAsInsertUniqueOptionIdentity() == Other.GetAsInsertUniqueOptionIdentity(); + case static_cast(EReducerTag::InsertUniqueOptionString): + return GetAsInsertUniqueOptionString() == Other.GetAsInsertUniqueOptionString(); + case static_cast(EReducerTag::InsertUniqueOptionU128): + return GetAsInsertUniqueOptionU128() == Other.GetAsInsertUniqueOptionU128(); + case static_cast(EReducerTag::InsertUniqueOptionU16): + return GetAsInsertUniqueOptionU16() == Other.GetAsInsertUniqueOptionU16(); + case static_cast(EReducerTag::InsertUniqueOptionU256): + return GetAsInsertUniqueOptionU256() == Other.GetAsInsertUniqueOptionU256(); + case static_cast(EReducerTag::InsertUniqueOptionU32): + return GetAsInsertUniqueOptionU32() == Other.GetAsInsertUniqueOptionU32(); + case static_cast(EReducerTag::InsertUniqueOptionU64): + return GetAsInsertUniqueOptionU64() == Other.GetAsInsertUniqueOptionU64(); + case static_cast(EReducerTag::InsertUniqueOptionU8): + return GetAsInsertUniqueOptionU8() == Other.GetAsInsertUniqueOptionU8(); + case static_cast(EReducerTag::InsertUniqueOptionUuid): + return GetAsInsertUniqueOptionUuid() == Other.GetAsInsertUniqueOptionUuid(); case static_cast(EReducerTag::InsertUniqueString): return GetAsInsertUniqueString() == Other.GetAsInsertUniqueString(); case static_cast(EReducerTag::InsertUniqueU128): @@ -6704,6 +8213,40 @@ struct TESTCLIENT_API FReducer return GetAsUpdateUniqueI8() == Other.GetAsUpdateUniqueI8(); case static_cast(EReducerTag::UpdateUniqueIdentity): return GetAsUpdateUniqueIdentity() == Other.GetAsUpdateUniqueIdentity(); + case static_cast(EReducerTag::UpdateUniqueOptionBool): + return GetAsUpdateUniqueOptionBool() == Other.GetAsUpdateUniqueOptionBool(); + case static_cast(EReducerTag::UpdateUniqueOptionConnectionId): + return GetAsUpdateUniqueOptionConnectionId() == Other.GetAsUpdateUniqueOptionConnectionId(); + case static_cast(EReducerTag::UpdateUniqueOptionI128): + return GetAsUpdateUniqueOptionI128() == Other.GetAsUpdateUniqueOptionI128(); + case static_cast(EReducerTag::UpdateUniqueOptionI16): + return GetAsUpdateUniqueOptionI16() == Other.GetAsUpdateUniqueOptionI16(); + case static_cast(EReducerTag::UpdateUniqueOptionI256): + return GetAsUpdateUniqueOptionI256() == Other.GetAsUpdateUniqueOptionI256(); + case static_cast(EReducerTag::UpdateUniqueOptionI32): + return GetAsUpdateUniqueOptionI32() == Other.GetAsUpdateUniqueOptionI32(); + case static_cast(EReducerTag::UpdateUniqueOptionI64): + return GetAsUpdateUniqueOptionI64() == Other.GetAsUpdateUniqueOptionI64(); + case static_cast(EReducerTag::UpdateUniqueOptionI8): + return GetAsUpdateUniqueOptionI8() == Other.GetAsUpdateUniqueOptionI8(); + case static_cast(EReducerTag::UpdateUniqueOptionIdentity): + return GetAsUpdateUniqueOptionIdentity() == Other.GetAsUpdateUniqueOptionIdentity(); + case static_cast(EReducerTag::UpdateUniqueOptionString): + return GetAsUpdateUniqueOptionString() == Other.GetAsUpdateUniqueOptionString(); + case static_cast(EReducerTag::UpdateUniqueOptionU128): + return GetAsUpdateUniqueOptionU128() == Other.GetAsUpdateUniqueOptionU128(); + case static_cast(EReducerTag::UpdateUniqueOptionU16): + return GetAsUpdateUniqueOptionU16() == Other.GetAsUpdateUniqueOptionU16(); + case static_cast(EReducerTag::UpdateUniqueOptionU256): + return GetAsUpdateUniqueOptionU256() == Other.GetAsUpdateUniqueOptionU256(); + case static_cast(EReducerTag::UpdateUniqueOptionU32): + return GetAsUpdateUniqueOptionU32() == Other.GetAsUpdateUniqueOptionU32(); + case static_cast(EReducerTag::UpdateUniqueOptionU64): + return GetAsUpdateUniqueOptionU64() == Other.GetAsUpdateUniqueOptionU64(); + case static_cast(EReducerTag::UpdateUniqueOptionU8): + return GetAsUpdateUniqueOptionU8() == Other.GetAsUpdateUniqueOptionU8(); + case static_cast(EReducerTag::UpdateUniqueOptionUuid): + return GetAsUpdateUniqueOptionUuid() == Other.GetAsUpdateUniqueOptionUuid(); case static_cast(EReducerTag::UpdateUniqueString): return GetAsUpdateUniqueString() == Other.GetAsUpdateUniqueString(); case static_cast(EReducerTag::UpdateUniqueU128): @@ -7500,6 +9043,227 @@ class TESTCLIENT_API UReducerBpLib : public UBlueprintFunctionLibrary return Reducer.GetAsDeleteAllUniqueIdentity(); } + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionBool(const FDeleteAllUniqueOptionBoolArgs& Value) { + return FReducer::DeleteAllUniqueOptionBool(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionBool(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionBool(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionBoolArgs GetAsDeleteAllUniqueOptionBool(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionBool(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionConnectionId(const FDeleteAllUniqueOptionConnectionIdArgs& Value) { + return FReducer::DeleteAllUniqueOptionConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionConnectionId(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionConnectionIdArgs GetAsDeleteAllUniqueOptionConnectionId(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI128(const FDeleteAllUniqueOptionI128Args& Value) { + return FReducer::DeleteAllUniqueOptionI128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI128(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI128Args GetAsDeleteAllUniqueOptionI128(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI16(const FDeleteAllUniqueOptionI16Args& Value) { + return FReducer::DeleteAllUniqueOptionI16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI16(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI16Args GetAsDeleteAllUniqueOptionI16(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI256(const FDeleteAllUniqueOptionI256Args& Value) { + return FReducer::DeleteAllUniqueOptionI256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI256(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI256Args GetAsDeleteAllUniqueOptionI256(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI32(const FDeleteAllUniqueOptionI32Args& Value) { + return FReducer::DeleteAllUniqueOptionI32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI32(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI32Args GetAsDeleteAllUniqueOptionI32(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI64(const FDeleteAllUniqueOptionI64Args& Value) { + return FReducer::DeleteAllUniqueOptionI64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI64(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI64Args GetAsDeleteAllUniqueOptionI64(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI8(const FDeleteAllUniqueOptionI8Args& Value) { + return FReducer::DeleteAllUniqueOptionI8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI8(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI8Args GetAsDeleteAllUniqueOptionI8(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionIdentity(const FDeleteAllUniqueOptionIdentityArgs& Value) { + return FReducer::DeleteAllUniqueOptionIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionIdentity(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionIdentityArgs GetAsDeleteAllUniqueOptionIdentity(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionString(const FDeleteAllUniqueOptionStringArgs& Value) { + return FReducer::DeleteAllUniqueOptionString(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionString(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionString(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionStringArgs GetAsDeleteAllUniqueOptionString(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionString(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU128(const FDeleteAllUniqueOptionU128Args& Value) { + return FReducer::DeleteAllUniqueOptionU128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU128(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU128Args GetAsDeleteAllUniqueOptionU128(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU16(const FDeleteAllUniqueOptionU16Args& Value) { + return FReducer::DeleteAllUniqueOptionU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU16(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU16Args GetAsDeleteAllUniqueOptionU16(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU256(const FDeleteAllUniqueOptionU256Args& Value) { + return FReducer::DeleteAllUniqueOptionU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU256(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU256Args GetAsDeleteAllUniqueOptionU256(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU32(const FDeleteAllUniqueOptionU32Args& Value) { + return FReducer::DeleteAllUniqueOptionU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU32(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU32Args GetAsDeleteAllUniqueOptionU32(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU64(const FDeleteAllUniqueOptionU64Args& Value) { + return FReducer::DeleteAllUniqueOptionU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU64(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU64Args GetAsDeleteAllUniqueOptionU64(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU8(const FDeleteAllUniqueOptionU8Args& Value) { + return FReducer::DeleteAllUniqueOptionU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU8(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU8Args GetAsDeleteAllUniqueOptionU8(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionUuid(const FDeleteAllUniqueOptionUuidArgs& Value) { + return FReducer::DeleteAllUniqueOptionUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionUuid(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionUuidArgs GetAsDeleteAllUniqueOptionUuid(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionUuid(); + } + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") static FReducer DeleteAllUniqueString(const FDeleteAllUniqueStringArgs& Value) { return FReducer::DeleteAllUniqueString(Value); @@ -8320,272 +10084,493 @@ class TESTCLIENT_API UReducerBpLib : public UBlueprintFunctionLibrary } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueString(const FDeleteUniqueStringArgs& Value) { - return FReducer::DeleteUniqueString(Value); + static FReducer DeleteUniqueOptionBool(const FDeleteUniqueOptionBoolArgs& Value) { + return FReducer::DeleteUniqueOptionBool(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueString(const FReducer& Reducer) { return Reducer.IsDeleteUniqueString(); } + static bool IsDeleteUniqueOptionBool(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionBool(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueStringArgs GetAsDeleteUniqueString(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueString(); + static FDeleteUniqueOptionBoolArgs GetAsDeleteUniqueOptionBool(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionBool(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU128(const FDeleteUniqueU128Args& Value) { - return FReducer::DeleteUniqueU128(Value); + static FReducer DeleteUniqueOptionConnectionId(const FDeleteUniqueOptionConnectionIdArgs& Value) { + return FReducer::DeleteUniqueOptionConnectionId(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU128(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU128(); } + static bool IsDeleteUniqueOptionConnectionId(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionConnectionId(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU128Args GetAsDeleteUniqueU128(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU128(); + static FDeleteUniqueOptionConnectionIdArgs GetAsDeleteUniqueOptionConnectionId(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionConnectionId(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU16(const FDeleteUniqueU16Args& Value) { - return FReducer::DeleteUniqueU16(Value); + static FReducer DeleteUniqueOptionI128(const FDeleteUniqueOptionI128Args& Value) { + return FReducer::DeleteUniqueOptionI128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU16(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU16(); } + static bool IsDeleteUniqueOptionI128(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU16Args GetAsDeleteUniqueU16(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU16(); + static FDeleteUniqueOptionI128Args GetAsDeleteUniqueOptionI128(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU256(const FDeleteUniqueU256Args& Value) { - return FReducer::DeleteUniqueU256(Value); + static FReducer DeleteUniqueOptionI16(const FDeleteUniqueOptionI16Args& Value) { + return FReducer::DeleteUniqueOptionI16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU256(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU256(); } + static bool IsDeleteUniqueOptionI16(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU256Args GetAsDeleteUniqueU256(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU256(); + static FDeleteUniqueOptionI16Args GetAsDeleteUniqueOptionI16(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU32(const FDeleteUniqueU32Args& Value) { - return FReducer::DeleteUniqueU32(Value); + static FReducer DeleteUniqueOptionI256(const FDeleteUniqueOptionI256Args& Value) { + return FReducer::DeleteUniqueOptionI256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU32(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU32(); } + static bool IsDeleteUniqueOptionI256(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI256(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU32Args GetAsDeleteUniqueU32(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU32(); + static FDeleteUniqueOptionI256Args GetAsDeleteUniqueOptionI256(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI256(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU64(const FDeleteUniqueU64Args& Value) { - return FReducer::DeleteUniqueU64(Value); + static FReducer DeleteUniqueOptionI32(const FDeleteUniqueOptionI32Args& Value) { + return FReducer::DeleteUniqueOptionI32(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU64(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU64(); } + static bool IsDeleteUniqueOptionI32(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI32(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU64Args GetAsDeleteUniqueU64(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU64(); + static FDeleteUniqueOptionI32Args GetAsDeleteUniqueOptionI32(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI32(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU8(const FDeleteUniqueU8Args& Value) { - return FReducer::DeleteUniqueU8(Value); + static FReducer DeleteUniqueOptionI64(const FDeleteUniqueOptionI64Args& Value) { + return FReducer::DeleteUniqueOptionI64(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU8(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU8(); } + static bool IsDeleteUniqueOptionI64(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI64(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU8Args GetAsDeleteUniqueU8(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU8(); + static FDeleteUniqueOptionI64Args GetAsDeleteUniqueOptionI64(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI64(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueUuid(const FDeleteUniqueUuidArgs& Value) { - return FReducer::DeleteUniqueUuid(Value); + static FReducer DeleteUniqueOptionI8(const FDeleteUniqueOptionI8Args& Value) { + return FReducer::DeleteUniqueOptionI8(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueUuid(const FReducer& Reducer) { return Reducer.IsDeleteUniqueUuid(); } + static bool IsDeleteUniqueOptionI8(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI8(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueUuidArgs GetAsDeleteUniqueUuid(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueUuid(); + static FDeleteUniqueOptionI8Args GetAsDeleteUniqueOptionI8(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI8(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallTimestamp(const FInsertCallTimestampArgs& Value) { - return FReducer::InsertCallTimestamp(Value); + static FReducer DeleteUniqueOptionIdentity(const FDeleteUniqueOptionIdentityArgs& Value) { + return FReducer::DeleteUniqueOptionIdentity(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallTimestamp(const FReducer& Reducer) { return Reducer.IsInsertCallTimestamp(); } + static bool IsDeleteUniqueOptionIdentity(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionIdentity(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallTimestampArgs GetAsInsertCallTimestamp(const FReducer& Reducer) { - return Reducer.GetAsInsertCallTimestamp(); + static FDeleteUniqueOptionIdentityArgs GetAsDeleteUniqueOptionIdentity(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionIdentity(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallUuidV4(const FInsertCallUuidV4Args& Value) { - return FReducer::InsertCallUuidV4(Value); + static FReducer DeleteUniqueOptionString(const FDeleteUniqueOptionStringArgs& Value) { + return FReducer::DeleteUniqueOptionString(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallUuidV4(const FReducer& Reducer) { return Reducer.IsInsertCallUuidV4(); } + static bool IsDeleteUniqueOptionString(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionString(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallUuidV4Args GetAsInsertCallUuidV4(const FReducer& Reducer) { - return Reducer.GetAsInsertCallUuidV4(); + static FDeleteUniqueOptionStringArgs GetAsDeleteUniqueOptionString(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionString(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallUuidV7(const FInsertCallUuidV7Args& Value) { - return FReducer::InsertCallUuidV7(Value); + static FReducer DeleteUniqueOptionU128(const FDeleteUniqueOptionU128Args& Value) { + return FReducer::DeleteUniqueOptionU128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallUuidV7(const FReducer& Reducer) { return Reducer.IsInsertCallUuidV7(); } + static bool IsDeleteUniqueOptionU128(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallUuidV7Args GetAsInsertCallUuidV7(const FReducer& Reducer) { - return Reducer.GetAsInsertCallUuidV7(); + static FDeleteUniqueOptionU128Args GetAsDeleteUniqueOptionU128(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerOneConnectionId(const FInsertCallerOneConnectionIdArgs& Value) { - return FReducer::InsertCallerOneConnectionId(Value); + static FReducer DeleteUniqueOptionU16(const FDeleteUniqueOptionU16Args& Value) { + return FReducer::DeleteUniqueOptionU16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerOneConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerOneConnectionId(); } + static bool IsDeleteUniqueOptionU16(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerOneConnectionIdArgs GetAsInsertCallerOneConnectionId(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerOneConnectionId(); + static FDeleteUniqueOptionU16Args GetAsDeleteUniqueOptionU16(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerOneIdentity(const FInsertCallerOneIdentityArgs& Value) { - return FReducer::InsertCallerOneIdentity(Value); + static FReducer DeleteUniqueOptionU256(const FDeleteUniqueOptionU256Args& Value) { + return FReducer::DeleteUniqueOptionU256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerOneIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerOneIdentity(); } + static bool IsDeleteUniqueOptionU256(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU256(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerOneIdentityArgs GetAsInsertCallerOneIdentity(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerOneIdentity(); + static FDeleteUniqueOptionU256Args GetAsDeleteUniqueOptionU256(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU256(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerPkConnectionId(const FInsertCallerPkConnectionIdArgs& Value) { - return FReducer::InsertCallerPkConnectionId(Value); + static FReducer DeleteUniqueOptionU32(const FDeleteUniqueOptionU32Args& Value) { + return FReducer::DeleteUniqueOptionU32(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerPkConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerPkConnectionId(); } + static bool IsDeleteUniqueOptionU32(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU32(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerPkConnectionIdArgs GetAsInsertCallerPkConnectionId(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerPkConnectionId(); + static FDeleteUniqueOptionU32Args GetAsDeleteUniqueOptionU32(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU32(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerPkIdentity(const FInsertCallerPkIdentityArgs& Value) { - return FReducer::InsertCallerPkIdentity(Value); + static FReducer DeleteUniqueOptionU64(const FDeleteUniqueOptionU64Args& Value) { + return FReducer::DeleteUniqueOptionU64(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerPkIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerPkIdentity(); } + static bool IsDeleteUniqueOptionU64(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU64(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerPkIdentityArgs GetAsInsertCallerPkIdentity(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerPkIdentity(); + static FDeleteUniqueOptionU64Args GetAsDeleteUniqueOptionU64(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU64(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerUniqueConnectionId(const FInsertCallerUniqueConnectionIdArgs& Value) { - return FReducer::InsertCallerUniqueConnectionId(Value); + static FReducer DeleteUniqueOptionU8(const FDeleteUniqueOptionU8Args& Value) { + return FReducer::DeleteUniqueOptionU8(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerUniqueConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerUniqueConnectionId(); } + static bool IsDeleteUniqueOptionU8(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU8(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerUniqueConnectionIdArgs GetAsInsertCallerUniqueConnectionId(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerUniqueConnectionId(); + static FDeleteUniqueOptionU8Args GetAsDeleteUniqueOptionU8(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU8(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerUniqueIdentity(const FInsertCallerUniqueIdentityArgs& Value) { - return FReducer::InsertCallerUniqueIdentity(Value); + static FReducer DeleteUniqueOptionUuid(const FDeleteUniqueOptionUuidArgs& Value) { + return FReducer::DeleteUniqueOptionUuid(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerUniqueIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerUniqueIdentity(); } + static bool IsDeleteUniqueOptionUuid(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionUuid(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerUniqueIdentityArgs GetAsInsertCallerUniqueIdentity(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerUniqueIdentity(); + static FDeleteUniqueOptionUuidArgs GetAsDeleteUniqueOptionUuid(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionUuid(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerVecConnectionId(const FInsertCallerVecConnectionIdArgs& Value) { - return FReducer::InsertCallerVecConnectionId(Value); + static FReducer DeleteUniqueString(const FDeleteUniqueStringArgs& Value) { + return FReducer::DeleteUniqueString(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerVecConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerVecConnectionId(); } + static bool IsDeleteUniqueString(const FReducer& Reducer) { return Reducer.IsDeleteUniqueString(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerVecConnectionIdArgs GetAsInsertCallerVecConnectionId(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerVecConnectionId(); + static FDeleteUniqueStringArgs GetAsDeleteUniqueString(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueString(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerVecIdentity(const FInsertCallerVecIdentityArgs& Value) { - return FReducer::InsertCallerVecIdentity(Value); + static FReducer DeleteUniqueU128(const FDeleteUniqueU128Args& Value) { + return FReducer::DeleteUniqueU128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerVecIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerVecIdentity(); } + static bool IsDeleteUniqueU128(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerVecIdentityArgs GetAsInsertCallerVecIdentity(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerVecIdentity(); + static FDeleteUniqueU128Args GetAsDeleteUniqueU128(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertIntoBtreeU32(const FInsertIntoBtreeU32Args& Value) { - return FReducer::InsertIntoBtreeU32(Value); + static FReducer DeleteUniqueU16(const FDeleteUniqueU16Args& Value) { + return FReducer::DeleteUniqueU16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertIntoBtreeU32(const FReducer& Reducer) { return Reducer.IsInsertIntoBtreeU32(); } + static bool IsDeleteUniqueU16(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertIntoBtreeU32Args GetAsInsertIntoBtreeU32(const FReducer& Reducer) { - return Reducer.GetAsInsertIntoBtreeU32(); + static FDeleteUniqueU16Args GetAsDeleteUniqueU16(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertIntoIndexedSimpleEnum(const FInsertIntoIndexedSimpleEnumArgs& Value) { - return FReducer::InsertIntoIndexedSimpleEnum(Value); + static FReducer DeleteUniqueU256(const FDeleteUniqueU256Args& Value) { + return FReducer::DeleteUniqueU256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertIntoIndexedSimpleEnum(const FReducer& Reducer) { return Reducer.IsInsertIntoIndexedSimpleEnum(); } + static bool IsDeleteUniqueU256(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueU256Args GetAsDeleteUniqueU256(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteUniqueU32(const FDeleteUniqueU32Args& Value) { + return FReducer::DeleteUniqueU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteUniqueU32(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueU32Args GetAsDeleteUniqueU32(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteUniqueU64(const FDeleteUniqueU64Args& Value) { + return FReducer::DeleteUniqueU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteUniqueU64(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueU64Args GetAsDeleteUniqueU64(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteUniqueU8(const FDeleteUniqueU8Args& Value) { + return FReducer::DeleteUniqueU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteUniqueU8(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueU8Args GetAsDeleteUniqueU8(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteUniqueUuid(const FDeleteUniqueUuidArgs& Value) { + return FReducer::DeleteUniqueUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteUniqueUuid(const FReducer& Reducer) { return Reducer.IsDeleteUniqueUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueUuidArgs GetAsDeleteUniqueUuid(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueUuid(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallTimestamp(const FInsertCallTimestampArgs& Value) { + return FReducer::InsertCallTimestamp(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallTimestamp(const FReducer& Reducer) { return Reducer.IsInsertCallTimestamp(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallTimestampArgs GetAsInsertCallTimestamp(const FReducer& Reducer) { + return Reducer.GetAsInsertCallTimestamp(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallUuidV4(const FInsertCallUuidV4Args& Value) { + return FReducer::InsertCallUuidV4(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallUuidV4(const FReducer& Reducer) { return Reducer.IsInsertCallUuidV4(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallUuidV4Args GetAsInsertCallUuidV4(const FReducer& Reducer) { + return Reducer.GetAsInsertCallUuidV4(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallUuidV7(const FInsertCallUuidV7Args& Value) { + return FReducer::InsertCallUuidV7(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallUuidV7(const FReducer& Reducer) { return Reducer.IsInsertCallUuidV7(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallUuidV7Args GetAsInsertCallUuidV7(const FReducer& Reducer) { + return Reducer.GetAsInsertCallUuidV7(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerOneConnectionId(const FInsertCallerOneConnectionIdArgs& Value) { + return FReducer::InsertCallerOneConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerOneConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerOneConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerOneConnectionIdArgs GetAsInsertCallerOneConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerOneConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerOneIdentity(const FInsertCallerOneIdentityArgs& Value) { + return FReducer::InsertCallerOneIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerOneIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerOneIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerOneIdentityArgs GetAsInsertCallerOneIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerOneIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerPkConnectionId(const FInsertCallerPkConnectionIdArgs& Value) { + return FReducer::InsertCallerPkConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerPkConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerPkConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerPkConnectionIdArgs GetAsInsertCallerPkConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerPkConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerPkIdentity(const FInsertCallerPkIdentityArgs& Value) { + return FReducer::InsertCallerPkIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerPkIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerPkIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerPkIdentityArgs GetAsInsertCallerPkIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerPkIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerUniqueConnectionId(const FInsertCallerUniqueConnectionIdArgs& Value) { + return FReducer::InsertCallerUniqueConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerUniqueConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerUniqueConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerUniqueConnectionIdArgs GetAsInsertCallerUniqueConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerUniqueConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerUniqueIdentity(const FInsertCallerUniqueIdentityArgs& Value) { + return FReducer::InsertCallerUniqueIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerUniqueIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerUniqueIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerUniqueIdentityArgs GetAsInsertCallerUniqueIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerUniqueIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerVecConnectionId(const FInsertCallerVecConnectionIdArgs& Value) { + return FReducer::InsertCallerVecConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerVecConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerVecConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerVecConnectionIdArgs GetAsInsertCallerVecConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerVecConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerVecIdentity(const FInsertCallerVecIdentityArgs& Value) { + return FReducer::InsertCallerVecIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerVecIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerVecIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerVecIdentityArgs GetAsInsertCallerVecIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerVecIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertIntoBtreeU32(const FInsertIntoBtreeU32Args& Value) { + return FReducer::InsertIntoBtreeU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertIntoBtreeU32(const FReducer& Reducer) { return Reducer.IsInsertIntoBtreeU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertIntoBtreeU32Args GetAsInsertIntoBtreeU32(const FReducer& Reducer) { + return Reducer.GetAsInsertIntoBtreeU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertIntoIndexedSimpleEnum(const FInsertIntoIndexedSimpleEnumArgs& Value) { + return FReducer::InsertIntoIndexedSimpleEnum(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertIntoIndexedSimpleEnum(const FReducer& Reducer) { return Reducer.IsInsertIntoIndexedSimpleEnum(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") static FInsertIntoIndexedSimpleEnumArgs GetAsInsertIntoIndexedSimpleEnum(const FReducer& Reducer) { @@ -9516,93 +11501,314 @@ class TESTCLIENT_API UReducerBpLib : public UBlueprintFunctionLibrary } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueString(const FInsertUniqueStringArgs& Value) { - return FReducer::InsertUniqueString(Value); + static FReducer InsertUniqueOptionBool(const FInsertUniqueOptionBoolArgs& Value) { + return FReducer::InsertUniqueOptionBool(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueString(const FReducer& Reducer) { return Reducer.IsInsertUniqueString(); } + static bool IsInsertUniqueOptionBool(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionBool(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueStringArgs GetAsInsertUniqueString(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueString(); + static FInsertUniqueOptionBoolArgs GetAsInsertUniqueOptionBool(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionBool(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU128(const FInsertUniqueU128Args& Value) { - return FReducer::InsertUniqueU128(Value); + static FReducer InsertUniqueOptionConnectionId(const FInsertUniqueOptionConnectionIdArgs& Value) { + return FReducer::InsertUniqueOptionConnectionId(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU128(const FReducer& Reducer) { return Reducer.IsInsertUniqueU128(); } + static bool IsInsertUniqueOptionConnectionId(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionConnectionId(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU128Args GetAsInsertUniqueU128(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU128(); + static FInsertUniqueOptionConnectionIdArgs GetAsInsertUniqueOptionConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionConnectionId(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU16(const FInsertUniqueU16Args& Value) { - return FReducer::InsertUniqueU16(Value); + static FReducer InsertUniqueOptionI128(const FInsertUniqueOptionI128Args& Value) { + return FReducer::InsertUniqueOptionI128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU16(const FReducer& Reducer) { return Reducer.IsInsertUniqueU16(); } + static bool IsInsertUniqueOptionI128(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU16Args GetAsInsertUniqueU16(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU16(); + static FInsertUniqueOptionI128Args GetAsInsertUniqueOptionI128(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU256(const FInsertUniqueU256Args& Value) { - return FReducer::InsertUniqueU256(Value); + static FReducer InsertUniqueOptionI16(const FInsertUniqueOptionI16Args& Value) { + return FReducer::InsertUniqueOptionI16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU256(const FReducer& Reducer) { return Reducer.IsInsertUniqueU256(); } + static bool IsInsertUniqueOptionI16(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU256Args GetAsInsertUniqueU256(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU256(); + static FInsertUniqueOptionI16Args GetAsInsertUniqueOptionI16(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU32(const FInsertUniqueU32Args& Value) { - return FReducer::InsertUniqueU32(Value); + static FReducer InsertUniqueOptionI256(const FInsertUniqueOptionI256Args& Value) { + return FReducer::InsertUniqueOptionI256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueU32(); } + static bool IsInsertUniqueOptionI256(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI256(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU32Args GetAsInsertUniqueU32(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU32(); + static FInsertUniqueOptionI256Args GetAsInsertUniqueOptionI256(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI256(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU32UpdatePkU32(const FInsertUniqueU32UpdatePkU32Args& Value) { - return FReducer::InsertUniqueU32UpdatePkU32(Value); + static FReducer InsertUniqueOptionI32(const FInsertUniqueOptionI32Args& Value) { + return FReducer::InsertUniqueOptionI32(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU32UpdatePkU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueU32UpdatePkU32(); } + static bool IsInsertUniqueOptionI32(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI32(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU32UpdatePkU32Args GetAsInsertUniqueU32UpdatePkU32(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU32UpdatePkU32(); + static FInsertUniqueOptionI32Args GetAsInsertUniqueOptionI32(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI32(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU64(const FInsertUniqueU64Args& Value) { - return FReducer::InsertUniqueU64(Value); + static FReducer InsertUniqueOptionI64(const FInsertUniqueOptionI64Args& Value) { + return FReducer::InsertUniqueOptionI64(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU64(const FReducer& Reducer) { return Reducer.IsInsertUniqueU64(); } + static bool IsInsertUniqueOptionI64(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI64(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU64Args GetAsInsertUniqueU64(const FReducer& Reducer) { + static FInsertUniqueOptionI64Args GetAsInsertUniqueOptionI64(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionI8(const FInsertUniqueOptionI8Args& Value) { + return FReducer::InsertUniqueOptionI8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionI8(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionI8Args GetAsInsertUniqueOptionI8(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionIdentity(const FInsertUniqueOptionIdentityArgs& Value) { + return FReducer::InsertUniqueOptionIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionIdentity(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionIdentityArgs GetAsInsertUniqueOptionIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionString(const FInsertUniqueOptionStringArgs& Value) { + return FReducer::InsertUniqueOptionString(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionString(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionString(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionStringArgs GetAsInsertUniqueOptionString(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionString(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU128(const FInsertUniqueOptionU128Args& Value) { + return FReducer::InsertUniqueOptionU128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU128(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU128Args GetAsInsertUniqueOptionU128(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU16(const FInsertUniqueOptionU16Args& Value) { + return FReducer::InsertUniqueOptionU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU16(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU16Args GetAsInsertUniqueOptionU16(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU256(const FInsertUniqueOptionU256Args& Value) { + return FReducer::InsertUniqueOptionU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU256(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU256Args GetAsInsertUniqueOptionU256(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU32(const FInsertUniqueOptionU32Args& Value) { + return FReducer::InsertUniqueOptionU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU32Args GetAsInsertUniqueOptionU32(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU64(const FInsertUniqueOptionU64Args& Value) { + return FReducer::InsertUniqueOptionU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU64(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU64Args GetAsInsertUniqueOptionU64(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU8(const FInsertUniqueOptionU8Args& Value) { + return FReducer::InsertUniqueOptionU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU8(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU8Args GetAsInsertUniqueOptionU8(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionUuid(const FInsertUniqueOptionUuidArgs& Value) { + return FReducer::InsertUniqueOptionUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionUuid(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionUuidArgs GetAsInsertUniqueOptionUuid(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionUuid(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueString(const FInsertUniqueStringArgs& Value) { + return FReducer::InsertUniqueString(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueString(const FReducer& Reducer) { return Reducer.IsInsertUniqueString(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueStringArgs GetAsInsertUniqueString(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueString(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU128(const FInsertUniqueU128Args& Value) { + return FReducer::InsertUniqueU128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU128(const FReducer& Reducer) { return Reducer.IsInsertUniqueU128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU128Args GetAsInsertUniqueU128(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU16(const FInsertUniqueU16Args& Value) { + return FReducer::InsertUniqueU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU16(const FReducer& Reducer) { return Reducer.IsInsertUniqueU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU16Args GetAsInsertUniqueU16(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU256(const FInsertUniqueU256Args& Value) { + return FReducer::InsertUniqueU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU256(const FReducer& Reducer) { return Reducer.IsInsertUniqueU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU256Args GetAsInsertUniqueU256(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU32(const FInsertUniqueU32Args& Value) { + return FReducer::InsertUniqueU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU32Args GetAsInsertUniqueU32(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU32UpdatePkU32(const FInsertUniqueU32UpdatePkU32Args& Value) { + return FReducer::InsertUniqueU32UpdatePkU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU32UpdatePkU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueU32UpdatePkU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU32UpdatePkU32Args GetAsInsertUniqueU32UpdatePkU32(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU32UpdatePkU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU64(const FInsertUniqueU64Args& Value) { + return FReducer::InsertUniqueU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU64(const FReducer& Reducer) { return Reducer.IsInsertUniqueU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU64Args GetAsInsertUniqueU64(const FReducer& Reducer) { return Reducer.GetAsInsertUniqueU64(); } @@ -10387,150 +12593,371 @@ class TESTCLIENT_API UReducerBpLib : public UBlueprintFunctionLibrary } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueString(const FUpdateUniqueStringArgs& Value) { - return FReducer::UpdateUniqueString(Value); + static FReducer UpdateUniqueOptionBool(const FUpdateUniqueOptionBoolArgs& Value) { + return FReducer::UpdateUniqueOptionBool(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueString(const FReducer& Reducer) { return Reducer.IsUpdateUniqueString(); } + static bool IsUpdateUniqueOptionBool(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionBool(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueStringArgs GetAsUpdateUniqueString(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueString(); + static FUpdateUniqueOptionBoolArgs GetAsUpdateUniqueOptionBool(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionBool(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU128(const FUpdateUniqueU128Args& Value) { - return FReducer::UpdateUniqueU128(Value); + static FReducer UpdateUniqueOptionConnectionId(const FUpdateUniqueOptionConnectionIdArgs& Value) { + return FReducer::UpdateUniqueOptionConnectionId(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU128(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU128(); } + static bool IsUpdateUniqueOptionConnectionId(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionConnectionId(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU128Args GetAsUpdateUniqueU128(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU128(); + static FUpdateUniqueOptionConnectionIdArgs GetAsUpdateUniqueOptionConnectionId(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionConnectionId(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU16(const FUpdateUniqueU16Args& Value) { - return FReducer::UpdateUniqueU16(Value); + static FReducer UpdateUniqueOptionI128(const FUpdateUniqueOptionI128Args& Value) { + return FReducer::UpdateUniqueOptionI128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU16(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU16(); } + static bool IsUpdateUniqueOptionI128(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU16Args GetAsUpdateUniqueU16(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU16(); + static FUpdateUniqueOptionI128Args GetAsUpdateUniqueOptionI128(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU256(const FUpdateUniqueU256Args& Value) { - return FReducer::UpdateUniqueU256(Value); + static FReducer UpdateUniqueOptionI16(const FUpdateUniqueOptionI16Args& Value) { + return FReducer::UpdateUniqueOptionI16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU256(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU256(); } + static bool IsUpdateUniqueOptionI16(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU256Args GetAsUpdateUniqueU256(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU256(); + static FUpdateUniqueOptionI16Args GetAsUpdateUniqueOptionI16(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU32(const FUpdateUniqueU32Args& Value) { - return FReducer::UpdateUniqueU32(Value); + static FReducer UpdateUniqueOptionI256(const FUpdateUniqueOptionI256Args& Value) { + return FReducer::UpdateUniqueOptionI256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU32(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU32(); } + static bool IsUpdateUniqueOptionI256(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI256(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU32Args GetAsUpdateUniqueU32(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU32(); + static FUpdateUniqueOptionI256Args GetAsUpdateUniqueOptionI256(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI256(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU64(const FUpdateUniqueU64Args& Value) { - return FReducer::UpdateUniqueU64(Value); + static FReducer UpdateUniqueOptionI32(const FUpdateUniqueOptionI32Args& Value) { + return FReducer::UpdateUniqueOptionI32(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU64(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU64(); } + static bool IsUpdateUniqueOptionI32(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI32(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU64Args GetAsUpdateUniqueU64(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU64(); + static FUpdateUniqueOptionI32Args GetAsUpdateUniqueOptionI32(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI32(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU8(const FUpdateUniqueU8Args& Value) { - return FReducer::UpdateUniqueU8(Value); + static FReducer UpdateUniqueOptionI64(const FUpdateUniqueOptionI64Args& Value) { + return FReducer::UpdateUniqueOptionI64(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU8(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU8(); } + static bool IsUpdateUniqueOptionI64(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI64(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU8Args GetAsUpdateUniqueU8(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU8(); + static FUpdateUniqueOptionI64Args GetAsUpdateUniqueOptionI64(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI64(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueUuid(const FUpdateUniqueUuidArgs& Value) { - return FReducer::UpdateUniqueUuid(Value); + static FReducer UpdateUniqueOptionI8(const FUpdateUniqueOptionI8Args& Value) { + return FReducer::UpdateUniqueOptionI8(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueUuid(const FReducer& Reducer) { return Reducer.IsUpdateUniqueUuid(); } + static bool IsUpdateUniqueOptionI8(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI8(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueUuidArgs GetAsUpdateUniqueUuid(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueUuid(); + static FUpdateUniqueOptionI8Args GetAsUpdateUniqueOptionI8(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI8(); } -}; -/** Metadata describing a reducer run. */ -USTRUCT(BlueprintType) -struct TESTCLIENT_API FTestClientReducerEvent -{ - GENERATED_BODY() + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionIdentity(const FUpdateUniqueOptionIdentityArgs& Value) { + return FReducer::UpdateUniqueOptionIdentity(Value); + } - /** Timestamp for when the reducer executed */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FSpacetimeDBTimestamp Timestamp; + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionIdentity(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionIdentity(); } - /** Result status of the reducer */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FSpacetimeDBStatus Status; + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionIdentityArgs GetAsUpdateUniqueOptionIdentity(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionIdentity(); + } - /** Identity that initiated the call */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FSpacetimeDBIdentity CallerIdentity; + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionString(const FUpdateUniqueOptionStringArgs& Value) { + return FReducer::UpdateUniqueOptionString(Value); + } - /** Connection ID for the caller */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FSpacetimeDBConnectionId CallerConnectionId; + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionString(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionString(); } - /** Energy consumed while executing */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FEnergyQuantaType EnergyConsumed; + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionStringArgs GetAsUpdateUniqueOptionString(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionString(); + } - /** Detailed call information */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FReducer Reducer; + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU128(const FUpdateUniqueOptionU128Args& Value) { + return FReducer::UpdateUniqueOptionU128(Value); + } - FORCEINLINE bool operator==(const FTestClientReducerEvent& Other) const - { - return Status == Other.Status && Timestamp == Other.Timestamp && CallerIdentity == Other.CallerIdentity && - CallerConnectionId == Other.CallerConnectionId && EnergyConsumed == Other.EnergyConsumed && - Reducer == Other.Reducer; - } + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU128(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU128(); } - FORCEINLINE bool operator!=(const FTestClientReducerEvent& Other) const - { - return !(*this == Other); + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU128Args GetAsUpdateUniqueOptionU128(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU16(const FUpdateUniqueOptionU16Args& Value) { + return FReducer::UpdateUniqueOptionU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU16(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU16Args GetAsUpdateUniqueOptionU16(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU256(const FUpdateUniqueOptionU256Args& Value) { + return FReducer::UpdateUniqueOptionU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU256(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU256Args GetAsUpdateUniqueOptionU256(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU32(const FUpdateUniqueOptionU32Args& Value) { + return FReducer::UpdateUniqueOptionU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU32(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU32Args GetAsUpdateUniqueOptionU32(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU64(const FUpdateUniqueOptionU64Args& Value) { + return FReducer::UpdateUniqueOptionU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU64(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU64Args GetAsUpdateUniqueOptionU64(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU8(const FUpdateUniqueOptionU8Args& Value) { + return FReducer::UpdateUniqueOptionU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU8(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU8Args GetAsUpdateUniqueOptionU8(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionUuid(const FUpdateUniqueOptionUuidArgs& Value) { + return FReducer::UpdateUniqueOptionUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionUuid(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionUuidArgs GetAsUpdateUniqueOptionUuid(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionUuid(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueString(const FUpdateUniqueStringArgs& Value) { + return FReducer::UpdateUniqueString(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueString(const FReducer& Reducer) { return Reducer.IsUpdateUniqueString(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueStringArgs GetAsUpdateUniqueString(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueString(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU128(const FUpdateUniqueU128Args& Value) { + return FReducer::UpdateUniqueU128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU128(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU128Args GetAsUpdateUniqueU128(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU16(const FUpdateUniqueU16Args& Value) { + return FReducer::UpdateUniqueU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU16(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU16Args GetAsUpdateUniqueU16(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU256(const FUpdateUniqueU256Args& Value) { + return FReducer::UpdateUniqueU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU256(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU256Args GetAsUpdateUniqueU256(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU32(const FUpdateUniqueU32Args& Value) { + return FReducer::UpdateUniqueU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU32(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU32Args GetAsUpdateUniqueU32(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU64(const FUpdateUniqueU64Args& Value) { + return FReducer::UpdateUniqueU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU64(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU64Args GetAsUpdateUniqueU64(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU8(const FUpdateUniqueU8Args& Value) { + return FReducer::UpdateUniqueU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU8(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU8Args GetAsUpdateUniqueU8(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueUuid(const FUpdateUniqueUuidArgs& Value) { + return FReducer::UpdateUniqueUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueUuid(const FReducer& Reducer) { return Reducer.IsUpdateUniqueUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueUuidArgs GetAsUpdateUniqueUuid(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueUuid(); + } +}; + +/** Metadata describing a reducer run. */ +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientReducerEvent +{ + GENERATED_BODY() + + /** Timestamp for when the reducer executed */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FSpacetimeDBTimestamp Timestamp; + + /** Result status of the reducer */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FSpacetimeDBStatus Status; + + /** Identity that initiated the call */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FSpacetimeDBIdentity CallerIdentity; + + /** Connection ID for the caller */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FSpacetimeDBConnectionId CallerConnectionId; + + /** Energy consumed while executing */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FEnergyQuantaType EnergyConsumed; + + /** Detailed call information */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FReducer Reducer; + + FORCEINLINE bool operator==(const FTestClientReducerEvent& Other) const + { + return Status == Other.Status && Timestamp == Other.Timestamp && CallerIdentity == Other.CallerIdentity && + CallerConnectionId == Other.CallerConnectionId && EnergyConsumed == Other.EnergyConsumed && + Reducer == Other.Reducer; + } + + FORCEINLINE bool operator!=(const FTestClientReducerEvent& Other) const + { + return !(*this == Other); } }; @@ -11119,6 +13546,57 @@ class TESTCLIENT_API URemoteTables : public UObject UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") UUniqueIdentityTable* UniqueIdentity; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionBoolTable* UniqueOptionBool; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionConnectionIdTable* UniqueOptionConnectionId; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI128Table* UniqueOptionI128; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI16Table* UniqueOptionI16; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI256Table* UniqueOptionI256; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI32Table* UniqueOptionI32; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI64Table* UniqueOptionI64; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI8Table* UniqueOptionI8; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionIdentityTable* UniqueOptionIdentity; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionStringTable* UniqueOptionString; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU128Table* UniqueOptionU128; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU16Table* UniqueOptionU16; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU256Table* UniqueOptionU256; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU32Table* UniqueOptionU32; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU64Table* UniqueOptionU64; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU8Table* UniqueOptionU8; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionUuidTable* UniqueOptionUuid; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") UUniqueStringTable* UniqueString; @@ -12088,58 +14566,313 @@ class TESTCLIENT_API URemoteReducers : public UObject bool InvokeDeleteAllUniqueIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueIdentityArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FDeleteAllUniqueStringHandler, + FDeleteAllUniqueOptionBoolHandler, const FReducerEventContext&, Context, - const FString&, S, + FTestClientOptionalBool, B, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteAllUniqueStringHandler OnDeleteAllUniqueString; + FDeleteAllUniqueOptionBoolHandler OnDeleteAllUniqueOptionBool; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteAllUniqueString(const FString& S, const int32 Data); + void DeleteAllUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data); - bool InvokeDeleteAllUniqueString(const FReducerEventContext& Context, const UDeleteAllUniqueStringReducer* Args); - bool InvokeDeleteAllUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueStringArgs& Args); + bool InvokeDeleteAllUniqueOptionBool(const FReducerEventContext& Context, const UDeleteAllUniqueOptionBoolReducer* Args); + bool InvokeDeleteAllUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionBoolArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FDeleteAllUniqueU128Handler, + FDeleteAllUniqueOptionConnectionIdHandler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt128&, N, + const FTestClientOptionalConnectionId&, A, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteAllUniqueU128Handler OnDeleteAllUniqueU128; + FDeleteAllUniqueOptionConnectionIdHandler OnDeleteAllUniqueOptionConnectionId; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + void DeleteAllUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data); - bool InvokeDeleteAllUniqueU128(const FReducerEventContext& Context, const UDeleteAllUniqueU128Reducer* Args); - bool InvokeDeleteAllUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU128Args& Args); + bool InvokeDeleteAllUniqueOptionConnectionId(const FReducerEventContext& Context, const UDeleteAllUniqueOptionConnectionIdReducer* Args); + bool InvokeDeleteAllUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionConnectionIdArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FDeleteAllUniqueU16Handler, + FDeleteAllUniqueOptionI128Handler, const FReducerEventContext&, Context, - uint16, N, + const FTestClientOptionalInt128&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - FDeleteAllUniqueU16Handler OnDeleteAllUniqueU16; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionI128Handler OnDeleteAllUniqueOptionI128; - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - void DeleteAllUniqueU16(const uint16 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data); - bool InvokeDeleteAllUniqueU16(const FReducerEventContext& Context, const UDeleteAllUniqueU16Reducer* Args); - bool InvokeDeleteAllUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU16Args& Args); + bool InvokeDeleteAllUniqueOptionI128(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI128Reducer* Args); + bool InvokeDeleteAllUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI128Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FDeleteAllUniqueU256Handler, + FDeleteAllUniqueOptionI16Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt256&, N, + FTestClientOptionalInt16, N, int32, Data ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteAllUniqueU256Handler OnDeleteAllUniqueU256; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FDeleteAllUniqueOptionI16Handler OnDeleteAllUniqueOptionI16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + void DeleteAllUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI16(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI16Reducer* Args); + bool InvokeDeleteAllUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionI256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionI256Handler OnDeleteAllUniqueOptionI256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI256(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI256Reducer* Args); + bool InvokeDeleteAllUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionI32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalInt32, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionI32Handler OnDeleteAllUniqueOptionI32; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI32(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI32Reducer* Args); + bool InvokeDeleteAllUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionI64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalInt64, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionI64Handler OnDeleteAllUniqueOptionI64; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI64(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI64Reducer* Args); + bool InvokeDeleteAllUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionI8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalInt8, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FDeleteAllUniqueOptionI8Handler OnDeleteAllUniqueOptionI8; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + void DeleteAllUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI8(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI8Reducer* Args); + bool InvokeDeleteAllUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionIdentityHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalIdentity&, I, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionIdentityHandler OnDeleteAllUniqueOptionIdentity; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data); + + bool InvokeDeleteAllUniqueOptionIdentity(const FReducerEventContext& Context, const UDeleteAllUniqueOptionIdentityReducer* Args); + bool InvokeDeleteAllUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionIdentityArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionStringHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionStringHandler OnDeleteAllUniqueOptionString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionString(const FTestClientOptionalString& S, const int32 Data); + + bool InvokeDeleteAllUniqueOptionString(const FReducerEventContext& Context, const UDeleteAllUniqueOptionStringReducer* Args); + bool InvokeDeleteAllUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU128Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionU128Handler OnDeleteAllUniqueOptionU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU128(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU128Reducer* Args); + bool InvokeDeleteAllUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU16Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FDeleteAllUniqueOptionU16Handler OnDeleteAllUniqueOptionU16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + void DeleteAllUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU16(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU16Reducer* Args); + bool InvokeDeleteAllUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionU256Handler OnDeleteAllUniqueOptionU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU256(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU256Reducer* Args); + bool InvokeDeleteAllUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FDeleteAllUniqueOptionU32Handler OnDeleteAllUniqueOptionU32; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + void DeleteAllUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU32(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU32Reducer* Args); + bool InvokeDeleteAllUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FDeleteAllUniqueOptionU64Handler OnDeleteAllUniqueOptionU64; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + void DeleteAllUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU64(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU64Reducer* Args); + bool InvokeDeleteAllUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt8, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionU8Handler OnDeleteAllUniqueOptionU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU8(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU8Reducer* Args); + bool InvokeDeleteAllUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionUuidHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalUuid&, U, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionUuidHandler OnDeleteAllUniqueOptionUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data); + + bool InvokeDeleteAllUniqueOptionUuid(const FReducerEventContext& Context, const UDeleteAllUniqueOptionUuidReducer* Args); + bool InvokeDeleteAllUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueStringHandler, + const FReducerEventContext&, Context, + const FString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueStringHandler OnDeleteAllUniqueString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueString(const FString& S, const int32 Data); + + bool InvokeDeleteAllUniqueString(const FReducerEventContext& Context, const UDeleteAllUniqueStringReducer* Args); + bool InvokeDeleteAllUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueU128Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueU128Handler OnDeleteAllUniqueU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + + bool InvokeDeleteAllUniqueU128(const FReducerEventContext& Context, const UDeleteAllUniqueU128Reducer* Args); + bool InvokeDeleteAllUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueU16Handler, + const FReducerEventContext&, Context, + uint16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + FDeleteAllUniqueU16Handler OnDeleteAllUniqueU16; + + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + void DeleteAllUniqueU16(const uint16 N, const int32 Data); + + bool InvokeDeleteAllUniqueU16(const FReducerEventContext& Context, const UDeleteAllUniqueU16Reducer* Args); + bool InvokeDeleteAllUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueU256Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueU256Handler OnDeleteAllUniqueU256; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") void DeleteAllUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); @@ -12979,149 +15712,387 @@ class TESTCLIENT_API URemoteReducers : public UObject bool InvokeDeleteUniqueIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueIdentityArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueStringHandler, + FDeleteUniqueOptionBoolHandler, const FReducerEventContext&, Context, - const FString&, S + FTestClientOptionalBool, B ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueStringHandler OnDeleteUniqueString; + FDeleteUniqueOptionBoolHandler OnDeleteUniqueOptionBool; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueString(const FString& S); + void DeleteUniqueOptionBool(const FTestClientOptionalBool B); - bool InvokeDeleteUniqueString(const FReducerEventContext& Context, const UDeleteUniqueStringReducer* Args); - bool InvokeDeleteUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueStringArgs& Args); + bool InvokeDeleteUniqueOptionBool(const FReducerEventContext& Context, const UDeleteUniqueOptionBoolReducer* Args); + bool InvokeDeleteUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionBoolArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU128Handler, + FDeleteUniqueOptionConnectionIdHandler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt128&, N + const FTestClientOptionalConnectionId&, A ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueU128Handler OnDeleteUniqueU128; + FDeleteUniqueOptionConnectionIdHandler OnDeleteUniqueOptionConnectionId; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueU128(const FSpacetimeDBUInt128& N); + void DeleteUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A); - bool InvokeDeleteUniqueU128(const FReducerEventContext& Context, const UDeleteUniqueU128Reducer* Args); - bool InvokeDeleteUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU128Args& Args); + bool InvokeDeleteUniqueOptionConnectionId(const FReducerEventContext& Context, const UDeleteUniqueOptionConnectionIdReducer* Args); + bool InvokeDeleteUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionConnectionIdArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU16Handler, + FDeleteUniqueOptionI128Handler, const FReducerEventContext&, Context, - uint16, N + const FTestClientOptionalInt128&, N ); - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - FDeleteUniqueU16Handler OnDeleteUniqueU16; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionI128Handler OnDeleteUniqueOptionI128; - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - void DeleteUniqueU16(const uint16 N); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionI128(const FTestClientOptionalInt128& N); - bool InvokeDeleteUniqueU16(const FReducerEventContext& Context, const UDeleteUniqueU16Reducer* Args); - bool InvokeDeleteUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU16Args& Args); + bool InvokeDeleteUniqueOptionI128(const FReducerEventContext& Context, const UDeleteUniqueOptionI128Reducer* Args); + bool InvokeDeleteUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI128Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU256Handler, + FDeleteUniqueOptionI16Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt256&, N + FTestClientOptionalInt16, N ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueU256Handler OnDeleteUniqueU256; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FDeleteUniqueOptionI16Handler OnDeleteUniqueOptionI16; - UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueU256(const FSpacetimeDBUInt256& N); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + void DeleteUniqueOptionI16(const FTestClientOptionalInt16 N); - bool InvokeDeleteUniqueU256(const FReducerEventContext& Context, const UDeleteUniqueU256Reducer* Args); - bool InvokeDeleteUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU256Args& Args); + bool InvokeDeleteUniqueOptionI16(const FReducerEventContext& Context, const UDeleteUniqueOptionI16Reducer* Args); + bool InvokeDeleteUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI16Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU32Handler, + FDeleteUniqueOptionI256Handler, const FReducerEventContext&, Context, - uint32, N + const FTestClientOptionalInt256&, N ); - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - FDeleteUniqueU32Handler OnDeleteUniqueU32; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionI256Handler OnDeleteUniqueOptionI256; - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - void DeleteUniqueU32(const uint32 N); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionI256(const FTestClientOptionalInt256& N); - bool InvokeDeleteUniqueU32(const FReducerEventContext& Context, const UDeleteUniqueU32Reducer* Args); - bool InvokeDeleteUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU32Args& Args); + bool InvokeDeleteUniqueOptionI256(const FReducerEventContext& Context, const UDeleteUniqueOptionI256Reducer* Args); + bool InvokeDeleteUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI256Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU64Handler, + FDeleteUniqueOptionI32Handler, const FReducerEventContext&, Context, - uint64, N + FTestClientOptionalInt32, N ); - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - FDeleteUniqueU64Handler OnDeleteUniqueU64; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionI32Handler OnDeleteUniqueOptionI32; - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - void DeleteUniqueU64(const uint64 N); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionI32(const FTestClientOptionalInt32 N); - bool InvokeDeleteUniqueU64(const FReducerEventContext& Context, const UDeleteUniqueU64Reducer* Args); - bool InvokeDeleteUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU64Args& Args); + bool InvokeDeleteUniqueOptionI32(const FReducerEventContext& Context, const UDeleteUniqueOptionI32Reducer* Args); + bool InvokeDeleteUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI32Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU8Handler, + FDeleteUniqueOptionI64Handler, const FReducerEventContext&, Context, - uint8, N + FTestClientOptionalInt64, N ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueU8Handler OnDeleteUniqueU8; + FDeleteUniqueOptionI64Handler OnDeleteUniqueOptionI64; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueU8(const uint8 N); + void DeleteUniqueOptionI64(const FTestClientOptionalInt64 N); - bool InvokeDeleteUniqueU8(const FReducerEventContext& Context, const UDeleteUniqueU8Reducer* Args); - bool InvokeDeleteUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU8Args& Args); + bool InvokeDeleteUniqueOptionI64(const FReducerEventContext& Context, const UDeleteUniqueOptionI64Reducer* Args); + bool InvokeDeleteUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI64Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueUuidHandler, + FDeleteUniqueOptionI8Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUuid&, U + FTestClientOptionalInt8, N ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueUuidHandler OnDeleteUniqueUuid; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FDeleteUniqueOptionI8Handler OnDeleteUniqueOptionI8; - UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueUuid(const FSpacetimeDBUuid& U); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + void DeleteUniqueOptionI8(const FTestClientOptionalInt8 N); - bool InvokeDeleteUniqueUuid(const FReducerEventContext& Context, const UDeleteUniqueUuidReducer* Args); - bool InvokeDeleteUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueUuidArgs& Args); + bool InvokeDeleteUniqueOptionI8(const FReducerEventContext& Context, const UDeleteUniqueOptionI8Reducer* Args); + bool InvokeDeleteUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI8Args& Args); - DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( - FInsertCallTimestampHandler, - const FReducerEventContext&, Context + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionIdentityHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalIdentity&, I ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertCallTimestampHandler OnInsertCallTimestamp; + FDeleteUniqueOptionIdentityHandler OnDeleteUniqueOptionIdentity; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertCallTimestamp(); + void DeleteUniqueOptionIdentity(const FTestClientOptionalIdentity& I); - bool InvokeInsertCallTimestamp(const FReducerEventContext& Context, const UInsertCallTimestampReducer* Args); - bool InvokeInsertCallTimestampWithArgs(const FReducerEventContext& Context, const FInsertCallTimestampArgs& Args); + bool InvokeDeleteUniqueOptionIdentity(const FReducerEventContext& Context, const UDeleteUniqueOptionIdentityReducer* Args); + bool InvokeDeleteUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionIdentityArgs& Args); - DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( - FInsertCallUuidV4Handler, - const FReducerEventContext&, Context + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionStringHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalString&, S ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertCallUuidV4Handler OnInsertCallUuidV4; + FDeleteUniqueOptionStringHandler OnDeleteUniqueOptionString; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertCallUuidV4(); + void DeleteUniqueOptionString(const FTestClientOptionalString& S); - bool InvokeInsertCallUuidV4(const FReducerEventContext& Context, const UInsertCallUuidV4Reducer* Args); - bool InvokeInsertCallUuidV4WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV4Args& Args); + bool InvokeDeleteUniqueOptionString(const FReducerEventContext& Context, const UDeleteUniqueOptionStringReducer* Args); + bool InvokeDeleteUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionStringArgs& Args); - DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( - FInsertCallUuidV7Handler, - const FReducerEventContext&, Context + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU128Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt128&, N ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertCallUuidV7Handler OnInsertCallUuidV7; + FDeleteUniqueOptionU128Handler OnDeleteUniqueOptionU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionU128(const FTestClientOptionalUInt128& N); + + bool InvokeDeleteUniqueOptionU128(const FReducerEventContext& Context, const UDeleteUniqueOptionU128Reducer* Args); + bool InvokeDeleteUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU16Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt16, N + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FDeleteUniqueOptionU16Handler OnDeleteUniqueOptionU16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + void DeleteUniqueOptionU16(const FTestClientOptionalUInt16 N); + + bool InvokeDeleteUniqueOptionU16(const FReducerEventContext& Context, const UDeleteUniqueOptionU16Reducer* Args); + bool InvokeDeleteUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt256&, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionU256Handler OnDeleteUniqueOptionU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionU256(const FTestClientOptionalUInt256& N); + + bool InvokeDeleteUniqueOptionU256(const FReducerEventContext& Context, const UDeleteUniqueOptionU256Reducer* Args); + bool InvokeDeleteUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt32, N + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FDeleteUniqueOptionU32Handler OnDeleteUniqueOptionU32; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + void DeleteUniqueOptionU32(const FTestClientOptionalUInt32 N); + + bool InvokeDeleteUniqueOptionU32(const FReducerEventContext& Context, const UDeleteUniqueOptionU32Reducer* Args); + bool InvokeDeleteUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt64, N + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FDeleteUniqueOptionU64Handler OnDeleteUniqueOptionU64; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + void DeleteUniqueOptionU64(const FTestClientOptionalUInt64 N); + + bool InvokeDeleteUniqueOptionU64(const FReducerEventContext& Context, const UDeleteUniqueOptionU64Reducer* Args); + bool InvokeDeleteUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt8, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionU8Handler OnDeleteUniqueOptionU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionU8(const FTestClientOptionalUInt8 N); + + bool InvokeDeleteUniqueOptionU8(const FReducerEventContext& Context, const UDeleteUniqueOptionU8Reducer* Args); + bool InvokeDeleteUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionUuidHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalUuid&, U + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionUuidHandler OnDeleteUniqueOptionUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionUuid(const FTestClientOptionalUuid& U); + + bool InvokeDeleteUniqueOptionUuid(const FReducerEventContext& Context, const UDeleteUniqueOptionUuidReducer* Args); + bool InvokeDeleteUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueStringHandler, + const FReducerEventContext&, Context, + const FString&, S + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueStringHandler OnDeleteUniqueString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueString(const FString& S); + + bool InvokeDeleteUniqueString(const FReducerEventContext& Context, const UDeleteUniqueStringReducer* Args); + bool InvokeDeleteUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU128Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt128&, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueU128Handler OnDeleteUniqueU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueU128(const FSpacetimeDBUInt128& N); + + bool InvokeDeleteUniqueU128(const FReducerEventContext& Context, const UDeleteUniqueU128Reducer* Args); + bool InvokeDeleteUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU16Handler, + const FReducerEventContext&, Context, + uint16, N + ); + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + FDeleteUniqueU16Handler OnDeleteUniqueU16; + + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + void DeleteUniqueU16(const uint16 N); + + bool InvokeDeleteUniqueU16(const FReducerEventContext& Context, const UDeleteUniqueU16Reducer* Args); + bool InvokeDeleteUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU256Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt256&, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueU256Handler OnDeleteUniqueU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueU256(const FSpacetimeDBUInt256& N); + + bool InvokeDeleteUniqueU256(const FReducerEventContext& Context, const UDeleteUniqueU256Reducer* Args); + bool InvokeDeleteUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU32Handler, + const FReducerEventContext&, Context, + uint32, N + ); + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + FDeleteUniqueU32Handler OnDeleteUniqueU32; + + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + void DeleteUniqueU32(const uint32 N); + + bool InvokeDeleteUniqueU32(const FReducerEventContext& Context, const UDeleteUniqueU32Reducer* Args); + bool InvokeDeleteUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU64Handler, + const FReducerEventContext&, Context, + uint64, N + ); + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + FDeleteUniqueU64Handler OnDeleteUniqueU64; + + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + void DeleteUniqueU64(const uint64 N); + + bool InvokeDeleteUniqueU64(const FReducerEventContext& Context, const UDeleteUniqueU64Reducer* Args); + bool InvokeDeleteUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU8Handler, + const FReducerEventContext&, Context, + uint8, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueU8Handler OnDeleteUniqueU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueU8(const uint8 N); + + bool InvokeDeleteUniqueU8(const FReducerEventContext& Context, const UDeleteUniqueU8Reducer* Args); + bool InvokeDeleteUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueUuidHandler, + const FReducerEventContext&, Context, + const FSpacetimeDBUuid&, U + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueUuidHandler OnDeleteUniqueUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueUuid(const FSpacetimeDBUuid& U); + + bool InvokeDeleteUniqueUuid(const FReducerEventContext& Context, const UDeleteUniqueUuidReducer* Args); + bool InvokeDeleteUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( + FInsertCallTimestampHandler, + const FReducerEventContext&, Context + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertCallTimestampHandler OnInsertCallTimestamp; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertCallTimestamp(); + + bool InvokeInsertCallTimestamp(const FReducerEventContext& Context, const UInsertCallTimestampReducer* Args); + bool InvokeInsertCallTimestampWithArgs(const FReducerEventContext& Context, const FInsertCallTimestampArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( + FInsertCallUuidV4Handler, + const FReducerEventContext&, Context + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertCallUuidV4Handler OnInsertCallUuidV4; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertCallUuidV4(); + + bool InvokeInsertCallUuidV4(const FReducerEventContext& Context, const UInsertCallUuidV4Reducer* Args); + bool InvokeInsertCallUuidV4WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV4Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( + FInsertCallUuidV7Handler, + const FReducerEventContext&, Context + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertCallUuidV7Handler OnInsertCallUuidV7; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") void InsertCallUuidV7(); @@ -14290,110 +17261,365 @@ class TESTCLIENT_API URemoteReducers : public UObject bool InvokeInsertUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueIdentityArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueStringHandler, + FInsertUniqueOptionBoolHandler, const FReducerEventContext&, Context, - const FString&, S, + FTestClientOptionalBool, B, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertUniqueStringHandler OnInsertUniqueString; + FInsertUniqueOptionBoolHandler OnInsertUniqueOptionBool; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertUniqueString(const FString& S, const int32 Data); + void InsertUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data); - bool InvokeInsertUniqueString(const FReducerEventContext& Context, const UInsertUniqueStringReducer* Args); - bool InvokeInsertUniqueStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueStringArgs& Args); + bool InvokeInsertUniqueOptionBool(const FReducerEventContext& Context, const UInsertUniqueOptionBoolReducer* Args); + bool InvokeInsertUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionBoolArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU128Handler, + FInsertUniqueOptionConnectionIdHandler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt128&, N, + const FTestClientOptionalConnectionId&, A, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertUniqueU128Handler OnInsertUniqueU128; + FInsertUniqueOptionConnectionIdHandler OnInsertUniqueOptionConnectionId; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + void InsertUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data); - bool InvokeInsertUniqueU128(const FReducerEventContext& Context, const UInsertUniqueU128Reducer* Args); - bool InvokeInsertUniqueU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueU128Args& Args); + bool InvokeInsertUniqueOptionConnectionId(const FReducerEventContext& Context, const UInsertUniqueOptionConnectionIdReducer* Args); + bool InvokeInsertUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionConnectionIdArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU16Handler, + FInsertUniqueOptionI128Handler, const FReducerEventContext&, Context, - uint16, N, + const FTestClientOptionalInt128&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - FInsertUniqueU16Handler OnInsertUniqueU16; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionI128Handler OnInsertUniqueOptionI128; - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - void InsertUniqueU16(const uint16 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data); - bool InvokeInsertUniqueU16(const FReducerEventContext& Context, const UInsertUniqueU16Reducer* Args); - bool InvokeInsertUniqueU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueU16Args& Args); + bool InvokeInsertUniqueOptionI128(const FReducerEventContext& Context, const UInsertUniqueOptionI128Reducer* Args); + bool InvokeInsertUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI128Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU256Handler, + FInsertUniqueOptionI16Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt256&, N, + FTestClientOptionalInt16, N, int32, Data ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertUniqueU256Handler OnInsertUniqueU256; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FInsertUniqueOptionI16Handler OnInsertUniqueOptionI16; - UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + void InsertUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data); - bool InvokeInsertUniqueU256(const FReducerEventContext& Context, const UInsertUniqueU256Reducer* Args); - bool InvokeInsertUniqueU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueU256Args& Args); + bool InvokeInsertUniqueOptionI16(const FReducerEventContext& Context, const UInsertUniqueOptionI16Reducer* Args); + bool InvokeInsertUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI16Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU32Handler, + FInsertUniqueOptionI256Handler, const FReducerEventContext&, Context, - uint32, N, + const FTestClientOptionalInt256&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - FInsertUniqueU32Handler OnInsertUniqueU32; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionI256Handler OnInsertUniqueOptionI256; - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - void InsertUniqueU32(const uint32 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data); - bool InvokeInsertUniqueU32(const FReducerEventContext& Context, const UInsertUniqueU32Reducer* Args); - bool InvokeInsertUniqueU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32Args& Args); + bool InvokeInsertUniqueOptionI256(const FReducerEventContext& Context, const UInsertUniqueOptionI256Reducer* Args); + bool InvokeInsertUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI256Args& Args); - DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams( - FInsertUniqueU32UpdatePkU32Handler, + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionI32Handler, const FReducerEventContext&, Context, - uint32, N, - int32, DUnique, - int32, DPk + FTestClientOptionalInt32, N, + int32, Data ); - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - FInsertUniqueU32UpdatePkU32Handler OnInsertUniqueU32UpdatePkU32; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionI32Handler OnInsertUniqueOptionI32; - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - void InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUnique, const int32 DPk); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data); - bool InvokeInsertUniqueU32UpdatePkU32(const FReducerEventContext& Context, const UInsertUniqueU32UpdatePkU32Reducer* Args); - bool InvokeInsertUniqueU32UpdatePkU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32UpdatePkU32Args& Args); + bool InvokeInsertUniqueOptionI32(const FReducerEventContext& Context, const UInsertUniqueOptionI32Reducer* Args); + bool InvokeInsertUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI32Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU64Handler, + FInsertUniqueOptionI64Handler, const FReducerEventContext&, Context, - uint64, N, + FTestClientOptionalInt64, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - FInsertUniqueU64Handler OnInsertUniqueU64; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionI64Handler OnInsertUniqueOptionI64; - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - void InsertUniqueU64(const uint64 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data); - bool InvokeInsertUniqueU64(const FReducerEventContext& Context, const UInsertUniqueU64Reducer* Args); - bool InvokeInsertUniqueU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueU64Args& Args); + bool InvokeInsertUniqueOptionI64(const FReducerEventContext& Context, const UInsertUniqueOptionI64Reducer* Args); + bool InvokeInsertUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionI8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalInt8, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FInsertUniqueOptionI8Handler OnInsertUniqueOptionI8; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + void InsertUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data); + + bool InvokeInsertUniqueOptionI8(const FReducerEventContext& Context, const UInsertUniqueOptionI8Reducer* Args); + bool InvokeInsertUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionIdentityHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalIdentity&, I, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionIdentityHandler OnInsertUniqueOptionIdentity; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data); + + bool InvokeInsertUniqueOptionIdentity(const FReducerEventContext& Context, const UInsertUniqueOptionIdentityReducer* Args); + bool InvokeInsertUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionIdentityArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionStringHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionStringHandler OnInsertUniqueOptionString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionString(const FTestClientOptionalString& S, const int32 Data); + + bool InvokeInsertUniqueOptionString(const FReducerEventContext& Context, const UInsertUniqueOptionStringReducer* Args); + bool InvokeInsertUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU128Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionU128Handler OnInsertUniqueOptionU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data); + + bool InvokeInsertUniqueOptionU128(const FReducerEventContext& Context, const UInsertUniqueOptionU128Reducer* Args); + bool InvokeInsertUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU16Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FInsertUniqueOptionU16Handler OnInsertUniqueOptionU16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + void InsertUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data); + + bool InvokeInsertUniqueOptionU16(const FReducerEventContext& Context, const UInsertUniqueOptionU16Reducer* Args); + bool InvokeInsertUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionU256Handler OnInsertUniqueOptionU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data); + + bool InvokeInsertUniqueOptionU256(const FReducerEventContext& Context, const UInsertUniqueOptionU256Reducer* Args); + bool InvokeInsertUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FInsertUniqueOptionU32Handler OnInsertUniqueOptionU32; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + void InsertUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data); + + bool InvokeInsertUniqueOptionU32(const FReducerEventContext& Context, const UInsertUniqueOptionU32Reducer* Args); + bool InvokeInsertUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FInsertUniqueOptionU64Handler OnInsertUniqueOptionU64; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + void InsertUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data); + + bool InvokeInsertUniqueOptionU64(const FReducerEventContext& Context, const UInsertUniqueOptionU64Reducer* Args); + bool InvokeInsertUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt8, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionU8Handler OnInsertUniqueOptionU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data); + + bool InvokeInsertUniqueOptionU8(const FReducerEventContext& Context, const UInsertUniqueOptionU8Reducer* Args); + bool InvokeInsertUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionUuidHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalUuid&, U, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionUuidHandler OnInsertUniqueOptionUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data); + + bool InvokeInsertUniqueOptionUuid(const FReducerEventContext& Context, const UInsertUniqueOptionUuidReducer* Args); + bool InvokeInsertUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueStringHandler, + const FReducerEventContext&, Context, + const FString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueStringHandler OnInsertUniqueString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueString(const FString& S, const int32 Data); + + bool InvokeInsertUniqueString(const FReducerEventContext& Context, const UInsertUniqueStringReducer* Args); + bool InvokeInsertUniqueStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU128Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueU128Handler OnInsertUniqueU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + + bool InvokeInsertUniqueU128(const FReducerEventContext& Context, const UInsertUniqueU128Reducer* Args); + bool InvokeInsertUniqueU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU16Handler, + const FReducerEventContext&, Context, + uint16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + FInsertUniqueU16Handler OnInsertUniqueU16; + + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + void InsertUniqueU16(const uint16 N, const int32 Data); + + bool InvokeInsertUniqueU16(const FReducerEventContext& Context, const UInsertUniqueU16Reducer* Args); + bool InvokeInsertUniqueU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU256Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueU256Handler OnInsertUniqueU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); + + bool InvokeInsertUniqueU256(const FReducerEventContext& Context, const UInsertUniqueU256Reducer* Args); + bool InvokeInsertUniqueU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU32Handler, + const FReducerEventContext&, Context, + uint32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + FInsertUniqueU32Handler OnInsertUniqueU32; + + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + void InsertUniqueU32(const uint32 N, const int32 Data); + + bool InvokeInsertUniqueU32(const FReducerEventContext& Context, const UInsertUniqueU32Reducer* Args); + bool InvokeInsertUniqueU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams( + FInsertUniqueU32UpdatePkU32Handler, + const FReducerEventContext&, Context, + uint32, N, + int32, DUnique, + int32, DPk + ); + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + FInsertUniqueU32UpdatePkU32Handler OnInsertUniqueU32UpdatePkU32; + + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + void InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUnique, const int32 DPk); + + bool InvokeInsertUniqueU32UpdatePkU32(const FReducerEventContext& Context, const UInsertUniqueU32UpdatePkU32Reducer* Args); + bool InvokeInsertUniqueU32UpdatePkU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32UpdatePkU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU64Handler, + const FReducerEventContext&, Context, + uint64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + FInsertUniqueU64Handler OnInsertUniqueU64; + + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + void InsertUniqueU64(const uint64 N, const int32 Data); + + bool InvokeInsertUniqueU64(const FReducerEventContext& Context, const UInsertUniqueU64Reducer* Args); + bool InvokeInsertUniqueU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueU64Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( FInsertUniqueU8Handler, @@ -15266,123 +18492,378 @@ class TESTCLIENT_API URemoteReducers : public UObject bool InvokeUpdateUniqueIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueIdentityArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueStringHandler, + FUpdateUniqueOptionBoolHandler, const FReducerEventContext&, Context, - const FString&, S, + FTestClientOptionalBool, B, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueStringHandler OnUpdateUniqueString; + FUpdateUniqueOptionBoolHandler OnUpdateUniqueOptionBool; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueString(const FString& S, const int32 Data); + void UpdateUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data); - bool InvokeUpdateUniqueString(const FReducerEventContext& Context, const UUpdateUniqueStringReducer* Args); - bool InvokeUpdateUniqueStringWithArgs(const FReducerEventContext& Context, const FUpdateUniqueStringArgs& Args); + bool InvokeUpdateUniqueOptionBool(const FReducerEventContext& Context, const UUpdateUniqueOptionBoolReducer* Args); + bool InvokeUpdateUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionBoolArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU128Handler, + FUpdateUniqueOptionConnectionIdHandler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt128&, N, + const FTestClientOptionalConnectionId&, A, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueU128Handler OnUpdateUniqueU128; + FUpdateUniqueOptionConnectionIdHandler OnUpdateUniqueOptionConnectionId; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + void UpdateUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data); - bool InvokeUpdateUniqueU128(const FReducerEventContext& Context, const UUpdateUniqueU128Reducer* Args); - bool InvokeUpdateUniqueU128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU128Args& Args); + bool InvokeUpdateUniqueOptionConnectionId(const FReducerEventContext& Context, const UUpdateUniqueOptionConnectionIdReducer* Args); + bool InvokeUpdateUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionConnectionIdArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU16Handler, + FUpdateUniqueOptionI128Handler, const FReducerEventContext&, Context, - uint16, N, + const FTestClientOptionalInt128&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - FUpdateUniqueU16Handler OnUpdateUniqueU16; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionI128Handler OnUpdateUniqueOptionI128; - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - void UpdateUniqueU16(const uint16 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data); - bool InvokeUpdateUniqueU16(const FReducerEventContext& Context, const UUpdateUniqueU16Reducer* Args); - bool InvokeUpdateUniqueU16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU16Args& Args); + bool InvokeUpdateUniqueOptionI128(const FReducerEventContext& Context, const UUpdateUniqueOptionI128Reducer* Args); + bool InvokeUpdateUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI128Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU256Handler, + FUpdateUniqueOptionI16Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt256&, N, + FTestClientOptionalInt16, N, int32, Data ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueU256Handler OnUpdateUniqueU256; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FUpdateUniqueOptionI16Handler OnUpdateUniqueOptionI16; - UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + void UpdateUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data); - bool InvokeUpdateUniqueU256(const FReducerEventContext& Context, const UUpdateUniqueU256Reducer* Args); - bool InvokeUpdateUniqueU256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU256Args& Args); + bool InvokeUpdateUniqueOptionI16(const FReducerEventContext& Context, const UUpdateUniqueOptionI16Reducer* Args); + bool InvokeUpdateUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI16Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU32Handler, + FUpdateUniqueOptionI256Handler, const FReducerEventContext&, Context, - uint32, N, + const FTestClientOptionalInt256&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - FUpdateUniqueU32Handler OnUpdateUniqueU32; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionI256Handler OnUpdateUniqueOptionI256; - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - void UpdateUniqueU32(const uint32 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data); - bool InvokeUpdateUniqueU32(const FReducerEventContext& Context, const UUpdateUniqueU32Reducer* Args); - bool InvokeUpdateUniqueU32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU32Args& Args); + bool InvokeUpdateUniqueOptionI256(const FReducerEventContext& Context, const UUpdateUniqueOptionI256Reducer* Args); + bool InvokeUpdateUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI256Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU64Handler, + FUpdateUniqueOptionI32Handler, const FReducerEventContext&, Context, - uint64, N, + FTestClientOptionalInt32, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - FUpdateUniqueU64Handler OnUpdateUniqueU64; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionI32Handler OnUpdateUniqueOptionI32; - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - void UpdateUniqueU64(const uint64 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data); - bool InvokeUpdateUniqueU64(const FReducerEventContext& Context, const UUpdateUniqueU64Reducer* Args); - bool InvokeUpdateUniqueU64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU64Args& Args); + bool InvokeUpdateUniqueOptionI32(const FReducerEventContext& Context, const UUpdateUniqueOptionI32Reducer* Args); + bool InvokeUpdateUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI32Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU8Handler, + FUpdateUniqueOptionI64Handler, const FReducerEventContext&, Context, - uint8, N, + FTestClientOptionalInt64, N, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueU8Handler OnUpdateUniqueU8; + FUpdateUniqueOptionI64Handler OnUpdateUniqueOptionI64; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueU8(const uint8 N, const int32 Data); + void UpdateUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data); - bool InvokeUpdateUniqueU8(const FReducerEventContext& Context, const UUpdateUniqueU8Reducer* Args); - bool InvokeUpdateUniqueU8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU8Args& Args); + bool InvokeUpdateUniqueOptionI64(const FReducerEventContext& Context, const UUpdateUniqueOptionI64Reducer* Args); + bool InvokeUpdateUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI64Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueUuidHandler, + FUpdateUniqueOptionI8Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUuid&, U, + FTestClientOptionalInt8, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FUpdateUniqueOptionI8Handler OnUpdateUniqueOptionI8; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + void UpdateUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data); + + bool InvokeUpdateUniqueOptionI8(const FReducerEventContext& Context, const UUpdateUniqueOptionI8Reducer* Args); + bool InvokeUpdateUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionIdentityHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalIdentity&, I, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueUuidHandler OnUpdateUniqueUuid; + FUpdateUniqueOptionIdentityHandler OnUpdateUniqueOptionIdentity; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data); + void UpdateUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data); - bool InvokeUpdateUniqueUuid(const FReducerEventContext& Context, const UUpdateUniqueUuidReducer* Args); + bool InvokeUpdateUniqueOptionIdentity(const FReducerEventContext& Context, const UUpdateUniqueOptionIdentityReducer* Args); + bool InvokeUpdateUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionIdentityArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionStringHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionStringHandler OnUpdateUniqueOptionString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionString(const FTestClientOptionalString& S, const int32 Data); + + bool InvokeUpdateUniqueOptionString(const FReducerEventContext& Context, const UUpdateUniqueOptionStringReducer* Args); + bool InvokeUpdateUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU128Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionU128Handler OnUpdateUniqueOptionU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data); + + bool InvokeUpdateUniqueOptionU128(const FReducerEventContext& Context, const UUpdateUniqueOptionU128Reducer* Args); + bool InvokeUpdateUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU16Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FUpdateUniqueOptionU16Handler OnUpdateUniqueOptionU16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + void UpdateUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data); + + bool InvokeUpdateUniqueOptionU16(const FReducerEventContext& Context, const UUpdateUniqueOptionU16Reducer* Args); + bool InvokeUpdateUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionU256Handler OnUpdateUniqueOptionU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data); + + bool InvokeUpdateUniqueOptionU256(const FReducerEventContext& Context, const UUpdateUniqueOptionU256Reducer* Args); + bool InvokeUpdateUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FUpdateUniqueOptionU32Handler OnUpdateUniqueOptionU32; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + void UpdateUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data); + + bool InvokeUpdateUniqueOptionU32(const FReducerEventContext& Context, const UUpdateUniqueOptionU32Reducer* Args); + bool InvokeUpdateUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FUpdateUniqueOptionU64Handler OnUpdateUniqueOptionU64; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + void UpdateUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data); + + bool InvokeUpdateUniqueOptionU64(const FReducerEventContext& Context, const UUpdateUniqueOptionU64Reducer* Args); + bool InvokeUpdateUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt8, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionU8Handler OnUpdateUniqueOptionU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data); + + bool InvokeUpdateUniqueOptionU8(const FReducerEventContext& Context, const UUpdateUniqueOptionU8Reducer* Args); + bool InvokeUpdateUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionUuidHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalUuid&, U, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionUuidHandler OnUpdateUniqueOptionUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data); + + bool InvokeUpdateUniqueOptionUuid(const FReducerEventContext& Context, const UUpdateUniqueOptionUuidReducer* Args); + bool InvokeUpdateUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueStringHandler, + const FReducerEventContext&, Context, + const FString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueStringHandler OnUpdateUniqueString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueString(const FString& S, const int32 Data); + + bool InvokeUpdateUniqueString(const FReducerEventContext& Context, const UUpdateUniqueStringReducer* Args); + bool InvokeUpdateUniqueStringWithArgs(const FReducerEventContext& Context, const FUpdateUniqueStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU128Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueU128Handler OnUpdateUniqueU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + + bool InvokeUpdateUniqueU128(const FReducerEventContext& Context, const UUpdateUniqueU128Reducer* Args); + bool InvokeUpdateUniqueU128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU16Handler, + const FReducerEventContext&, Context, + uint16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + FUpdateUniqueU16Handler OnUpdateUniqueU16; + + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + void UpdateUniqueU16(const uint16 N, const int32 Data); + + bool InvokeUpdateUniqueU16(const FReducerEventContext& Context, const UUpdateUniqueU16Reducer* Args); + bool InvokeUpdateUniqueU16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU256Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueU256Handler OnUpdateUniqueU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); + + bool InvokeUpdateUniqueU256(const FReducerEventContext& Context, const UUpdateUniqueU256Reducer* Args); + bool InvokeUpdateUniqueU256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU32Handler, + const FReducerEventContext&, Context, + uint32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + FUpdateUniqueU32Handler OnUpdateUniqueU32; + + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + void UpdateUniqueU32(const uint32 N, const int32 Data); + + bool InvokeUpdateUniqueU32(const FReducerEventContext& Context, const UUpdateUniqueU32Reducer* Args); + bool InvokeUpdateUniqueU32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU64Handler, + const FReducerEventContext&, Context, + uint64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + FUpdateUniqueU64Handler OnUpdateUniqueU64; + + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + void UpdateUniqueU64(const uint64 N, const int32 Data); + + bool InvokeUpdateUniqueU64(const FReducerEventContext& Context, const UUpdateUniqueU64Reducer* Args); + bool InvokeUpdateUniqueU64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU8Handler, + const FReducerEventContext&, Context, + uint8, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueU8Handler OnUpdateUniqueU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueU8(const uint8 N, const int32 Data); + + bool InvokeUpdateUniqueU8(const FReducerEventContext& Context, const UUpdateUniqueU8Reducer* Args); + bool InvokeUpdateUniqueU8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueUuidHandler, + const FReducerEventContext&, Context, + const FSpacetimeDBUuid&, U, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueUuidHandler OnUpdateUniqueUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data); + + bool InvokeUpdateUniqueUuid(const FReducerEventContext& Context, const UUpdateUniqueUuidReducer* Args); bool InvokeUpdateUniqueUuidWithArgs(const FReducerEventContext& Context, const FUpdateUniqueUuidArgs& Args); // Internal error handling @@ -15562,6 +19043,40 @@ struct TESTCLIENT_API FUniqueI8Cols; struct TESTCLIENT_API FUniqueI8IxCols; struct TESTCLIENT_API FUniqueIdentityCols; struct TESTCLIENT_API FUniqueIdentityIxCols; +struct TESTCLIENT_API FUniqueOptionBoolCols; +struct TESTCLIENT_API FUniqueOptionBoolIxCols; +struct TESTCLIENT_API FUniqueOptionConnectionIdCols; +struct TESTCLIENT_API FUniqueOptionConnectionIdIxCols; +struct TESTCLIENT_API FUniqueOptionI128Cols; +struct TESTCLIENT_API FUniqueOptionI128IxCols; +struct TESTCLIENT_API FUniqueOptionI16Cols; +struct TESTCLIENT_API FUniqueOptionI16IxCols; +struct TESTCLIENT_API FUniqueOptionI256Cols; +struct TESTCLIENT_API FUniqueOptionI256IxCols; +struct TESTCLIENT_API FUniqueOptionI32Cols; +struct TESTCLIENT_API FUniqueOptionI32IxCols; +struct TESTCLIENT_API FUniqueOptionI64Cols; +struct TESTCLIENT_API FUniqueOptionI64IxCols; +struct TESTCLIENT_API FUniqueOptionI8Cols; +struct TESTCLIENT_API FUniqueOptionI8IxCols; +struct TESTCLIENT_API FUniqueOptionIdentityCols; +struct TESTCLIENT_API FUniqueOptionIdentityIxCols; +struct TESTCLIENT_API FUniqueOptionStringCols; +struct TESTCLIENT_API FUniqueOptionStringIxCols; +struct TESTCLIENT_API FUniqueOptionU128Cols; +struct TESTCLIENT_API FUniqueOptionU128IxCols; +struct TESTCLIENT_API FUniqueOptionU16Cols; +struct TESTCLIENT_API FUniqueOptionU16IxCols; +struct TESTCLIENT_API FUniqueOptionU256Cols; +struct TESTCLIENT_API FUniqueOptionU256IxCols; +struct TESTCLIENT_API FUniqueOptionU32Cols; +struct TESTCLIENT_API FUniqueOptionU32IxCols; +struct TESTCLIENT_API FUniqueOptionU64Cols; +struct TESTCLIENT_API FUniqueOptionU64IxCols; +struct TESTCLIENT_API FUniqueOptionU8Cols; +struct TESTCLIENT_API FUniqueOptionU8IxCols; +struct TESTCLIENT_API FUniqueOptionUuidCols; +struct TESTCLIENT_API FUniqueOptionUuidIxCols; struct TESTCLIENT_API FUniqueStringCols; struct TESTCLIENT_API FUniqueStringIxCols; struct TESTCLIENT_API FUniqueU128Cols; @@ -17229,581 +20744,615 @@ namespace SpacetimeDB::query_builder struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueStringCols +struct TESTCLIENT_API FUniqueOptionBoolCols { - explicit FUniqueStringCols(const char* TableName) - : S(TableName, "s"), Data(TableName, "data") {} + explicit FUniqueOptionBoolCols(const char* TableName) + : B(TableName, "b"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col S; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col B; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueStringIxCols +struct TESTCLIENT_API FUniqueOptionBoolIxCols { - explicit FUniqueStringIxCols(const char* TableName) - : S(TableName, "s") {} + explicit FUniqueOptionBoolIxCols(const char* TableName) + : B(TableName, "b") {} - ::SpacetimeDB::query_builder::IxCol S; + ::SpacetimeDB::query_builder::IxCol B; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU128Cols +struct TESTCLIENT_API FUniqueOptionConnectionIdCols { - explicit FUniqueU128Cols(const char* TableName) - : N(TableName, "n"), Data(TableName, "data") {} + explicit FUniqueOptionConnectionIdCols(const char* TableName) + : A(TableName, "a"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col A; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU128IxCols +struct TESTCLIENT_API FUniqueOptionConnectionIdIxCols { - explicit FUniqueU128IxCols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueOptionConnectionIdIxCols(const char* TableName) + : A(TableName, "a") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol A; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU16Cols +struct TESTCLIENT_API FUniqueOptionI128Cols { - explicit FUniqueU16Cols(const char* TableName) + explicit FUniqueOptionI128Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU16IxCols +struct TESTCLIENT_API FUniqueOptionI128IxCols { - explicit FUniqueU16IxCols(const char* TableName) + explicit FUniqueOptionI128IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU256Cols +struct TESTCLIENT_API FUniqueOptionI16Cols { - explicit FUniqueU256Cols(const char* TableName) + explicit FUniqueOptionI16Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU256IxCols +struct TESTCLIENT_API FUniqueOptionI16IxCols { - explicit FUniqueU256IxCols(const char* TableName) + explicit FUniqueOptionI16IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU32Cols +struct TESTCLIENT_API FUniqueOptionI256Cols { - explicit FUniqueU32Cols(const char* TableName) + explicit FUniqueOptionI256Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU32IxCols +struct TESTCLIENT_API FUniqueOptionI256IxCols { - explicit FUniqueU32IxCols(const char* TableName) + explicit FUniqueOptionI256IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU64Cols +struct TESTCLIENT_API FUniqueOptionI32Cols { - explicit FUniqueU64Cols(const char* TableName) + explicit FUniqueOptionI32Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU64IxCols +struct TESTCLIENT_API FUniqueOptionI32IxCols { - explicit FUniqueU64IxCols(const char* TableName) + explicit FUniqueOptionI32IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU8Cols +struct TESTCLIENT_API FUniqueOptionI64Cols { - explicit FUniqueU8Cols(const char* TableName) + explicit FUniqueOptionI64Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU8IxCols +struct TESTCLIENT_API FUniqueOptionI64IxCols { - explicit FUniqueU8IxCols(const char* TableName) + explicit FUniqueOptionI64IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueUuidCols +struct TESTCLIENT_API FUniqueOptionI8Cols { - explicit FUniqueUuidCols(const char* TableName) - : U(TableName, "u"), Data(TableName, "data") {} + explicit FUniqueOptionI8Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col U; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueUuidIxCols +struct TESTCLIENT_API FUniqueOptionI8IxCols { - explicit FUniqueUuidIxCols(const char* TableName) - : U(TableName, "u") {} + explicit FUniqueOptionI8IxCols(const char* TableName) + : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol U; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUsersCols +struct TESTCLIENT_API FUniqueOptionIdentityCols { - explicit FUsersCols(const char* TableName) - : Identity(TableName, "identity"), Name(TableName, "name") {} + explicit FUniqueOptionIdentityCols(const char* TableName) + : I(TableName, "i"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col Identity; - ::SpacetimeDB::query_builder::Col Name; + ::SpacetimeDB::query_builder::Col I; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUsersIxCols +struct TESTCLIENT_API FUniqueOptionIdentityIxCols { - explicit FUsersIxCols(const char* TableName) - : Identity(TableName, "identity") {} + explicit FUniqueOptionIdentityIxCols(const char* TableName) + : I(TableName, "i") {} - ::SpacetimeDB::query_builder::IxCol Identity; + ::SpacetimeDB::query_builder::IxCol I; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecBoolCols +struct TESTCLIENT_API FUniqueOptionStringCols { - explicit FVecBoolCols(const char* TableName) - : B(TableName, "b") {} + explicit FUniqueOptionStringCols(const char* TableName) + : S(TableName, "s"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> B; + ::SpacetimeDB::query_builder::Col S; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecBoolIxCols +struct TESTCLIENT_API FUniqueOptionStringIxCols { - explicit FVecBoolIxCols(const char* TableName) - {} + explicit FUniqueOptionStringIxCols(const char* TableName) + : S(TableName, "s") {} + ::SpacetimeDB::query_builder::IxCol S; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecByteStructCols +struct TESTCLIENT_API FUniqueOptionU128Cols { - explicit FVecByteStructCols(const char* TableName) - : S(TableName, "s") {} + explicit FUniqueOptionU128Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecByteStructIxCols +struct TESTCLIENT_API FUniqueOptionU128IxCols { - explicit FVecByteStructIxCols(const char* TableName) - {} + explicit FUniqueOptionU128IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecConnectionIdCols +struct TESTCLIENT_API FUniqueOptionU16Cols { - explicit FVecConnectionIdCols(const char* TableName) - : A(TableName, "a") {} + explicit FUniqueOptionU16Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> A; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecConnectionIdIxCols +struct TESTCLIENT_API FUniqueOptionU16IxCols { - explicit FVecConnectionIdIxCols(const char* TableName) - {} + explicit FUniqueOptionU16IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecEnumWithPayloadCols +struct TESTCLIENT_API FUniqueOptionU256Cols { - explicit FVecEnumWithPayloadCols(const char* TableName) - : E(TableName, "e") {} + explicit FUniqueOptionU256Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> E; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecEnumWithPayloadIxCols +struct TESTCLIENT_API FUniqueOptionU256IxCols { - explicit FVecEnumWithPayloadIxCols(const char* TableName) - {} + explicit FUniqueOptionU256IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecEveryPrimitiveStructCols +struct TESTCLIENT_API FUniqueOptionU32Cols { - explicit FVecEveryPrimitiveStructCols(const char* TableName) - : S(TableName, "s") {} + explicit FUniqueOptionU32Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecEveryPrimitiveStructIxCols +struct TESTCLIENT_API FUniqueOptionU32IxCols { - explicit FVecEveryPrimitiveStructIxCols(const char* TableName) - {} + explicit FUniqueOptionU32IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecEveryVecStructCols +struct TESTCLIENT_API FUniqueOptionU64Cols { - explicit FVecEveryVecStructCols(const char* TableName) - : S(TableName, "s") {} + explicit FUniqueOptionU64Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecEveryVecStructIxCols +struct TESTCLIENT_API FUniqueOptionU64IxCols { - explicit FVecEveryVecStructIxCols(const char* TableName) - {} + explicit FUniqueOptionU64IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecF32Cols +struct TESTCLIENT_API FUniqueOptionU8Cols { - explicit FVecF32Cols(const char* TableName) - : F(TableName, "f") {} + explicit FUniqueOptionU8Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> F; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecF32IxCols +struct TESTCLIENT_API FUniqueOptionU8IxCols { - explicit FVecF32IxCols(const char* TableName) - {} + explicit FUniqueOptionU8IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecF64Cols +struct TESTCLIENT_API FUniqueOptionUuidCols { - explicit FVecF64Cols(const char* TableName) - : F(TableName, "f") {} + explicit FUniqueOptionUuidCols(const char* TableName) + : U(TableName, "u"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> F; + ::SpacetimeDB::query_builder::Col U; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecF64IxCols +struct TESTCLIENT_API FUniqueOptionUuidIxCols { - explicit FVecF64IxCols(const char* TableName) - {} + explicit FUniqueOptionUuidIxCols(const char* TableName) + : U(TableName, "u") {} + ::SpacetimeDB::query_builder::IxCol U; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI128Cols +struct TESTCLIENT_API FUniqueStringCols { - explicit FVecI128Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueStringCols(const char* TableName) + : S(TableName, "s"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col S; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI128IxCols +struct TESTCLIENT_API FUniqueStringIxCols { - explicit FVecI128IxCols(const char* TableName) - {} + explicit FUniqueStringIxCols(const char* TableName) + : S(TableName, "s") {} + ::SpacetimeDB::query_builder::IxCol S; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI16Cols +struct TESTCLIENT_API FUniqueU128Cols { - explicit FVecI16Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU128Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI16IxCols +struct TESTCLIENT_API FUniqueU128IxCols { - explicit FVecI16IxCols(const char* TableName) - {} + explicit FUniqueU128IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI256Cols +struct TESTCLIENT_API FUniqueU16Cols { - explicit FVecI256Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU16Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI256IxCols +struct TESTCLIENT_API FUniqueU16IxCols { - explicit FVecI256IxCols(const char* TableName) - {} + explicit FUniqueU16IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI32Cols +struct TESTCLIENT_API FUniqueU256Cols { - explicit FVecI32Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU256Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI32IxCols +struct TESTCLIENT_API FUniqueU256IxCols { - explicit FVecI32IxCols(const char* TableName) - {} + explicit FUniqueU256IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI64Cols +struct TESTCLIENT_API FUniqueU32Cols { - explicit FVecI64Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU32Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI64IxCols +struct TESTCLIENT_API FUniqueU32IxCols { - explicit FVecI64IxCols(const char* TableName) - {} + explicit FUniqueU32IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI8Cols +struct TESTCLIENT_API FUniqueU64Cols { - explicit FVecI8Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU64Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI8IxCols +struct TESTCLIENT_API FUniqueU64IxCols { - explicit FVecI8IxCols(const char* TableName) - {} + explicit FUniqueU64IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecIdentityCols +struct TESTCLIENT_API FUniqueU8Cols { - explicit FVecIdentityCols(const char* TableName) - : I(TableName, "i") {} + explicit FUniqueU8Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> I; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecIdentityIxCols +struct TESTCLIENT_API FUniqueU8IxCols { - explicit FVecIdentityIxCols(const char* TableName) - {} + explicit FUniqueU8IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecSimpleEnumCols +struct TESTCLIENT_API FUniqueUuidCols { - explicit FVecSimpleEnumCols(const char* TableName) - : E(TableName, "e") {} + explicit FUniqueUuidCols(const char* TableName) + : U(TableName, "u"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> E; + ::SpacetimeDB::query_builder::Col U; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecSimpleEnumIxCols +struct TESTCLIENT_API FUniqueUuidIxCols { - explicit FVecSimpleEnumIxCols(const char* TableName) - {} + explicit FUniqueUuidIxCols(const char* TableName) + : U(TableName, "u") {} + ::SpacetimeDB::query_builder::IxCol U; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecStringCols +struct TESTCLIENT_API FUsersCols { - explicit FVecStringCols(const char* TableName) - : S(TableName, "s") {} + explicit FUsersCols(const char* TableName) + : Identity(TableName, "identity"), Name(TableName, "name") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col Identity; + ::SpacetimeDB::query_builder::Col Name; }; -struct TESTCLIENT_API FVecStringIxCols +struct TESTCLIENT_API FUsersIxCols { - explicit FVecStringIxCols(const char* TableName) - {} + explicit FUsersIxCols(const char* TableName) + : Identity(TableName, "identity") {} + ::SpacetimeDB::query_builder::IxCol Identity; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecTimestampCols +struct TESTCLIENT_API FVecBoolCols { - explicit FVecTimestampCols(const char* TableName) - : T(TableName, "t") {} + explicit FVecBoolCols(const char* TableName) + : B(TableName, "b") {} - ::SpacetimeDB::query_builder::Col> T; + ::SpacetimeDB::query_builder::Col> B; }; -struct TESTCLIENT_API FVecTimestampIxCols +struct TESTCLIENT_API FVecBoolIxCols { - explicit FVecTimestampIxCols(const char* TableName) + explicit FVecBoolIxCols(const char* TableName) {} }; @@ -17811,20 +21360,20 @@ struct TESTCLIENT_API FVecTimestampIxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU128Cols +struct TESTCLIENT_API FVecByteStructCols { - explicit FVecU128Cols(const char* TableName) - : N(TableName, "n") {} + explicit FVecByteStructCols(const char* TableName) + : S(TableName, "s") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> S; }; -struct TESTCLIENT_API FVecU128IxCols +struct TESTCLIENT_API FVecByteStructIxCols { - explicit FVecU128IxCols(const char* TableName) + explicit FVecByteStructIxCols(const char* TableName) {} }; @@ -17832,20 +21381,146 @@ struct TESTCLIENT_API FVecU128IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU16Cols +struct TESTCLIENT_API FVecConnectionIdCols { - explicit FVecU16Cols(const char* TableName) + explicit FVecConnectionIdCols(const char* TableName) + : A(TableName, "a") {} + + ::SpacetimeDB::query_builder::Col> A; +}; + +struct TESTCLIENT_API FVecConnectionIdIxCols +{ + explicit FVecConnectionIdIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecEnumWithPayloadCols +{ + explicit FVecEnumWithPayloadCols(const char* TableName) + : E(TableName, "e") {} + + ::SpacetimeDB::query_builder::Col> E; +}; + +struct TESTCLIENT_API FVecEnumWithPayloadIxCols +{ + explicit FVecEnumWithPayloadIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecEveryPrimitiveStructCols +{ + explicit FVecEveryPrimitiveStructCols(const char* TableName) + : S(TableName, "s") {} + + ::SpacetimeDB::query_builder::Col> S; +}; + +struct TESTCLIENT_API FVecEveryPrimitiveStructIxCols +{ + explicit FVecEveryPrimitiveStructIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecEveryVecStructCols +{ + explicit FVecEveryVecStructCols(const char* TableName) + : S(TableName, "s") {} + + ::SpacetimeDB::query_builder::Col> S; +}; + +struct TESTCLIENT_API FVecEveryVecStructIxCols +{ + explicit FVecEveryVecStructIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecF32Cols +{ + explicit FVecF32Cols(const char* TableName) + : F(TableName, "f") {} + + ::SpacetimeDB::query_builder::Col> F; +}; + +struct TESTCLIENT_API FVecF32IxCols +{ + explicit FVecF32IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecF64Cols +{ + explicit FVecF64Cols(const char* TableName) + : F(TableName, "f") {} + + ::SpacetimeDB::query_builder::Col> F; +}; + +struct TESTCLIENT_API FVecF64IxCols +{ + explicit FVecF64IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecI128Cols +{ + explicit FVecI128Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU16IxCols +struct TESTCLIENT_API FVecI128IxCols { - explicit FVecU16IxCols(const char* TableName) + explicit FVecI128IxCols(const char* TableName) {} }; @@ -17853,20 +21528,20 @@ struct TESTCLIENT_API FVecU16IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU256Cols +struct TESTCLIENT_API FVecI16Cols { - explicit FVecU256Cols(const char* TableName) + explicit FVecI16Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU256IxCols +struct TESTCLIENT_API FVecI16IxCols { - explicit FVecU256IxCols(const char* TableName) + explicit FVecI16IxCols(const char* TableName) {} }; @@ -17874,20 +21549,20 @@ struct TESTCLIENT_API FVecU256IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU32Cols +struct TESTCLIENT_API FVecI256Cols { - explicit FVecU32Cols(const char* TableName) + explicit FVecI256Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU32IxCols +struct TESTCLIENT_API FVecI256IxCols { - explicit FVecU32IxCols(const char* TableName) + explicit FVecI256IxCols(const char* TableName) {} }; @@ -17895,20 +21570,20 @@ struct TESTCLIENT_API FVecU32IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU64Cols +struct TESTCLIENT_API FVecI32Cols { - explicit FVecU64Cols(const char* TableName) + explicit FVecI32Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU64IxCols +struct TESTCLIENT_API FVecI32IxCols { - explicit FVecU64IxCols(const char* TableName) + explicit FVecI32IxCols(const char* TableName) {} }; @@ -17916,20 +21591,20 @@ struct TESTCLIENT_API FVecU64IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU8Cols +struct TESTCLIENT_API FVecI64Cols { - explicit FVecU8Cols(const char* TableName) + explicit FVecI64Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU8IxCols +struct TESTCLIENT_API FVecI64IxCols { - explicit FVecU8IxCols(const char* TableName) + explicit FVecI64IxCols(const char* TableName) {} }; @@ -17937,20 +21612,20 @@ struct TESTCLIENT_API FVecU8IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecUnitStructCols +struct TESTCLIENT_API FVecI8Cols { - explicit FVecUnitStructCols(const char* TableName) - : S(TableName, "s") {} + explicit FVecI8Cols(const char* TableName) + : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecUnitStructIxCols +struct TESTCLIENT_API FVecI8IxCols { - explicit FVecUnitStructIxCols(const char* TableName) + explicit FVecI8IxCols(const char* TableName) {} }; @@ -17958,20 +21633,20 @@ struct TESTCLIENT_API FVecUnitStructIxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecUuidCols +struct TESTCLIENT_API FVecIdentityCols { - explicit FVecUuidCols(const char* TableName) - : U(TableName, "u") {} + explicit FVecIdentityCols(const char* TableName) + : I(TableName, "i") {} - ::SpacetimeDB::query_builder::Col> U; + ::SpacetimeDB::query_builder::Col> I; }; -struct TESTCLIENT_API FVecUuidIxCols +struct TESTCLIENT_API FVecIdentityIxCols { - explicit FVecUuidIxCols(const char* TableName) + explicit FVecIdentityIxCols(const char* TableName) {} }; @@ -17979,20 +21654,251 @@ struct TESTCLIENT_API FVecUuidIxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FFrom +struct TESTCLIENT_API FVecSimpleEnumCols { - [[nodiscard]] ::SpacetimeDB::query_builder::Table BtreeU32() const { return ::SpacetimeDB::query_builder::Table("btree_u_32", FBTreeU32Cols("btree_u_32"), FBTreeU32IxCols("btree_u_32")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table IndexedSimpleEnum() const { return ::SpacetimeDB::query_builder::Table("indexed_simple_enum", FIndexedSimpleEnumCols("indexed_simple_enum"), FIndexedSimpleEnumIxCols("indexed_simple_enum")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table LargeTable() const { return ::SpacetimeDB::query_builder::Table("large_table", FLargeTableCols("large_table"), FLargeTableIxCols("large_table")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneBool() const { return ::SpacetimeDB::query_builder::Table("one_bool", FOneBoolCols("one_bool"), FOneBoolIxCols("one_bool")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneByteStruct() const { return ::SpacetimeDB::query_builder::Table("one_byte_struct", FOneByteStructCols("one_byte_struct"), FOneByteStructIxCols("one_byte_struct")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneConnectionId() const { return ::SpacetimeDB::query_builder::Table("one_connection_id", FOneConnectionIdCols("one_connection_id"), FOneConnectionIdIxCols("one_connection_id")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEnumWithPayload() const { return ::SpacetimeDB::query_builder::Table("one_enum_with_payload", FOneEnumWithPayloadCols("one_enum_with_payload"), FOneEnumWithPayloadIxCols("one_enum_with_payload")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEveryPrimitiveStruct() const { return ::SpacetimeDB::query_builder::Table("one_every_primitive_struct", FOneEveryPrimitiveStructCols("one_every_primitive_struct"), FOneEveryPrimitiveStructIxCols("one_every_primitive_struct")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEveryVecStruct() const { return ::SpacetimeDB::query_builder::Table("one_every_vec_struct", FOneEveryVecStructCols("one_every_vec_struct"), FOneEveryVecStructIxCols("one_every_vec_struct")); } + explicit FVecSimpleEnumCols(const char* TableName) + : E(TableName, "e") {} + + ::SpacetimeDB::query_builder::Col> E; +}; + +struct TESTCLIENT_API FVecSimpleEnumIxCols +{ + explicit FVecSimpleEnumIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecStringCols +{ + explicit FVecStringCols(const char* TableName) + : S(TableName, "s") {} + + ::SpacetimeDB::query_builder::Col> S; +}; + +struct TESTCLIENT_API FVecStringIxCols +{ + explicit FVecStringIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecTimestampCols +{ + explicit FVecTimestampCols(const char* TableName) + : T(TableName, "t") {} + + ::SpacetimeDB::query_builder::Col> T; +}; + +struct TESTCLIENT_API FVecTimestampIxCols +{ + explicit FVecTimestampIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU128Cols +{ + explicit FVecU128Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU128IxCols +{ + explicit FVecU128IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU16Cols +{ + explicit FVecU16Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU16IxCols +{ + explicit FVecU16IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU256Cols +{ + explicit FVecU256Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU256IxCols +{ + explicit FVecU256IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU32Cols +{ + explicit FVecU32Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU32IxCols +{ + explicit FVecU32IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU64Cols +{ + explicit FVecU64Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU64IxCols +{ + explicit FVecU64IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU8Cols +{ + explicit FVecU8Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU8IxCols +{ + explicit FVecU8IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecUnitStructCols +{ + explicit FVecUnitStructCols(const char* TableName) + : S(TableName, "s") {} + + ::SpacetimeDB::query_builder::Col> S; +}; + +struct TESTCLIENT_API FVecUnitStructIxCols +{ + explicit FVecUnitStructIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecUuidCols +{ + explicit FVecUuidCols(const char* TableName) + : U(TableName, "u") {} + + ::SpacetimeDB::query_builder::Col> U; +}; + +struct TESTCLIENT_API FVecUuidIxCols +{ + explicit FVecUuidIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FFrom +{ + [[nodiscard]] ::SpacetimeDB::query_builder::Table BtreeU32() const { return ::SpacetimeDB::query_builder::Table("btree_u_32", FBTreeU32Cols("btree_u_32"), FBTreeU32IxCols("btree_u_32")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table IndexedSimpleEnum() const { return ::SpacetimeDB::query_builder::Table("indexed_simple_enum", FIndexedSimpleEnumCols("indexed_simple_enum"), FIndexedSimpleEnumIxCols("indexed_simple_enum")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table LargeTable() const { return ::SpacetimeDB::query_builder::Table("large_table", FLargeTableCols("large_table"), FLargeTableIxCols("large_table")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneBool() const { return ::SpacetimeDB::query_builder::Table("one_bool", FOneBoolCols("one_bool"), FOneBoolIxCols("one_bool")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneByteStruct() const { return ::SpacetimeDB::query_builder::Table("one_byte_struct", FOneByteStructCols("one_byte_struct"), FOneByteStructIxCols("one_byte_struct")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneConnectionId() const { return ::SpacetimeDB::query_builder::Table("one_connection_id", FOneConnectionIdCols("one_connection_id"), FOneConnectionIdIxCols("one_connection_id")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEnumWithPayload() const { return ::SpacetimeDB::query_builder::Table("one_enum_with_payload", FOneEnumWithPayloadCols("one_enum_with_payload"), FOneEnumWithPayloadIxCols("one_enum_with_payload")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEveryPrimitiveStruct() const { return ::SpacetimeDB::query_builder::Table("one_every_primitive_struct", FOneEveryPrimitiveStructCols("one_every_primitive_struct"), FOneEveryPrimitiveStructIxCols("one_every_primitive_struct")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEveryVecStruct() const { return ::SpacetimeDB::query_builder::Table("one_every_vec_struct", FOneEveryVecStructCols("one_every_vec_struct"), FOneEveryVecStructIxCols("one_every_vec_struct")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table OneF32() const { return ::SpacetimeDB::query_builder::Table("one_f_32", FOneF32Cols("one_f_32"), FOneF32IxCols("one_f_32")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table OneF64() const { return ::SpacetimeDB::query_builder::Table("one_f_64", FOneF64Cols("one_f_64"), FOneF64IxCols("one_f_64")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table OneI128() const { return ::SpacetimeDB::query_builder::Table("one_i_128", FOneI128Cols("one_i_128"), FOneI128IxCols("one_i_128")); } @@ -18056,6 +21962,23 @@ struct TESTCLIENT_API FFrom [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueI64() const { return ::SpacetimeDB::query_builder::Table("unique_i_64", FUniqueI64Cols("unique_i_64"), FUniqueI64IxCols("unique_i_64")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueI8() const { return ::SpacetimeDB::query_builder::Table("unique_i_8", FUniqueI8Cols("unique_i_8"), FUniqueI8IxCols("unique_i_8")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueIdentity() const { return ::SpacetimeDB::query_builder::Table("unique_identity", FUniqueIdentityCols("unique_identity"), FUniqueIdentityIxCols("unique_identity")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionBool() const { return ::SpacetimeDB::query_builder::Table("unique_option_bool", FUniqueOptionBoolCols("unique_option_bool"), FUniqueOptionBoolIxCols("unique_option_bool")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionConnectionId() const { return ::SpacetimeDB::query_builder::Table("unique_option_connection_id", FUniqueOptionConnectionIdCols("unique_option_connection_id"), FUniqueOptionConnectionIdIxCols("unique_option_connection_id")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI128() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_128", FUniqueOptionI128Cols("unique_option_i_128"), FUniqueOptionI128IxCols("unique_option_i_128")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI16() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_16", FUniqueOptionI16Cols("unique_option_i_16"), FUniqueOptionI16IxCols("unique_option_i_16")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI256() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_256", FUniqueOptionI256Cols("unique_option_i_256"), FUniqueOptionI256IxCols("unique_option_i_256")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI32() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_32", FUniqueOptionI32Cols("unique_option_i_32"), FUniqueOptionI32IxCols("unique_option_i_32")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI64() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_64", FUniqueOptionI64Cols("unique_option_i_64"), FUniqueOptionI64IxCols("unique_option_i_64")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI8() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_8", FUniqueOptionI8Cols("unique_option_i_8"), FUniqueOptionI8IxCols("unique_option_i_8")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionIdentity() const { return ::SpacetimeDB::query_builder::Table("unique_option_identity", FUniqueOptionIdentityCols("unique_option_identity"), FUniqueOptionIdentityIxCols("unique_option_identity")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionString() const { return ::SpacetimeDB::query_builder::Table("unique_option_string", FUniqueOptionStringCols("unique_option_string"), FUniqueOptionStringIxCols("unique_option_string")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU128() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_128", FUniqueOptionU128Cols("unique_option_u_128"), FUniqueOptionU128IxCols("unique_option_u_128")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU16() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_16", FUniqueOptionU16Cols("unique_option_u_16"), FUniqueOptionU16IxCols("unique_option_u_16")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU256() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_256", FUniqueOptionU256Cols("unique_option_u_256"), FUniqueOptionU256IxCols("unique_option_u_256")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU32() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_32", FUniqueOptionU32Cols("unique_option_u_32"), FUniqueOptionU32IxCols("unique_option_u_32")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU64() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_64", FUniqueOptionU64Cols("unique_option_u_64"), FUniqueOptionU64IxCols("unique_option_u_64")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU8() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_8", FUniqueOptionU8Cols("unique_option_u_8"), FUniqueOptionU8IxCols("unique_option_u_8")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionUuid() const { return ::SpacetimeDB::query_builder::Table("unique_option_uuid", FUniqueOptionUuidCols("unique_option_uuid"), FUniqueOptionUuidIxCols("unique_option_uuid")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueString() const { return ::SpacetimeDB::query_builder::Table("unique_string", FUniqueStringCols("unique_string"), FUniqueStringIxCols("unique_string")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueU128() const { return ::SpacetimeDB::query_builder::Table("unique_u_128", FUniqueU128Cols("unique_u_128"), FUniqueU128IxCols("unique_u_128")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueU16() const { return ::SpacetimeDB::query_builder::Table("unique_u_16", FUniqueU16Cols("unique_u_16"), FUniqueU16IxCols("unique_u_16")); } @@ -18172,6 +22095,23 @@ struct TESTCLIENT_API FQueryBuilder Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI64().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI8().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueIdentity().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionBool().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionConnectionId().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI128().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI16().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI256().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI32().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI64().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI8().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionIdentity().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionString().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU128().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU16().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU256().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU32().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU64().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU8().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionUuid().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueString().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueU128().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueU16().into_sql().c_str()))); @@ -19100,7 +23040,7 @@ struct TESTCLIENT_API FUniqueIdentityQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueStringQuery +struct TESTCLIENT_API FUniqueOptionBoolQuery { GENERATED_BODY() @@ -19112,7 +23052,7 @@ struct TESTCLIENT_API FUniqueStringQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU128Query +struct TESTCLIENT_API FUniqueOptionConnectionIdQuery { GENERATED_BODY() @@ -19124,7 +23064,7 @@ struct TESTCLIENT_API FUniqueU128Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU16Query +struct TESTCLIENT_API FUniqueOptionI128Query { GENERATED_BODY() @@ -19136,7 +23076,7 @@ struct TESTCLIENT_API FUniqueU16Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU256Query +struct TESTCLIENT_API FUniqueOptionI16Query { GENERATED_BODY() @@ -19148,7 +23088,7 @@ struct TESTCLIENT_API FUniqueU256Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU32Query +struct TESTCLIENT_API FUniqueOptionI256Query { GENERATED_BODY() @@ -19160,7 +23100,7 @@ struct TESTCLIENT_API FUniqueU32Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU64Query +struct TESTCLIENT_API FUniqueOptionI32Query { GENERATED_BODY() @@ -19172,7 +23112,7 @@ struct TESTCLIENT_API FUniqueU64Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU8Query +struct TESTCLIENT_API FUniqueOptionI64Query { GENERATED_BODY() @@ -19184,7 +23124,7 @@ struct TESTCLIENT_API FUniqueU8Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueUuidQuery +struct TESTCLIENT_API FUniqueOptionI8Query { GENERATED_BODY() @@ -19196,7 +23136,7 @@ struct TESTCLIENT_API FUniqueUuidQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUsersQuery +struct TESTCLIENT_API FUniqueOptionIdentityQuery { GENERATED_BODY() @@ -19208,7 +23148,7 @@ struct TESTCLIENT_API FUsersQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecBoolQuery +struct TESTCLIENT_API FUniqueOptionStringQuery { GENERATED_BODY() @@ -19220,7 +23160,7 @@ struct TESTCLIENT_API FVecBoolQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecByteStructQuery +struct TESTCLIENT_API FUniqueOptionU128Query { GENERATED_BODY() @@ -19232,7 +23172,7 @@ struct TESTCLIENT_API FVecByteStructQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecConnectionIdQuery +struct TESTCLIENT_API FUniqueOptionU16Query { GENERATED_BODY() @@ -19244,7 +23184,7 @@ struct TESTCLIENT_API FVecConnectionIdQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecEnumWithPayloadQuery +struct TESTCLIENT_API FUniqueOptionU256Query { GENERATED_BODY() @@ -19256,7 +23196,7 @@ struct TESTCLIENT_API FVecEnumWithPayloadQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecEveryPrimitiveStructQuery +struct TESTCLIENT_API FUniqueOptionU32Query { GENERATED_BODY() @@ -19268,7 +23208,7 @@ struct TESTCLIENT_API FVecEveryPrimitiveStructQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecEveryVecStructQuery +struct TESTCLIENT_API FUniqueOptionU64Query { GENERATED_BODY() @@ -19280,7 +23220,211 @@ struct TESTCLIENT_API FVecEveryVecStructQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecF32Query +struct TESTCLIENT_API FUniqueOptionU8Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionUuidQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueStringQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU128Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU16Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU256Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU32Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU64Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU8Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueUuidQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUsersQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecBoolQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecByteStructQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecConnectionIdQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecEnumWithPayloadQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecEveryPrimitiveStructQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecEveryVecStructQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecF32Query { GENERATED_BODY() @@ -19782,32 +23926,597 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable N")) static FBlueprintFloatColumn LargeTableN(const FLargeTableQuery& Query) { - FBlueprintFloatColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; + FBlueprintFloatColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable O")) + static FBlueprintDoubleColumn LargeTableO(const FLargeTableQuery& Query) + { + FBlueprintDoubleColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; + Column.ColumnName = TEXT("o"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable P")) + static FBlueprintStringColumn LargeTableP(const FLargeTableQuery& Query) + { + FBlueprintStringColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; + Column.ColumnName = TEXT("p"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable", meta=(DisplayName="LargeTable Where")) + static FLargeTableQuery LargeTableWhere(FLargeTableQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="From OneBool")) + static FOneBoolQuery FromOneBool() + { + FOneBoolQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneBool().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_bool"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneBoolQueryToBlueprintQuery(const FOneBoolQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool|Columns", meta=(DisplayName="OneBool B")) + static FBlueprintBoolColumn OneBoolB(const FOneBoolQuery& Query) + { + FBlueprintBoolColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("b"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="OneBool Where")) + static FOneBoolQuery OneBoolWhere(FOneBoolQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="From OneByteStruct")) + static FOneByteStructQuery FromOneByteStruct() + { + FOneByteStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneByteStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_byte_struct"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneByteStructQueryToBlueprintQuery(const FOneByteStructQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="OneByteStruct Where")) + static FOneByteStructQuery OneByteStructWhere(FOneByteStructQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="From OneConnectionId")) + static FOneConnectionIdQuery FromOneConnectionId() + { + FOneConnectionIdQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneConnectionId().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_connection_id"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneConnectionIdQueryToBlueprintQuery(const FOneConnectionIdQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId|Columns", meta=(DisplayName="OneConnectionId A")) + static FBlueprintConnectionIdColumn OneConnectionIdA(const FOneConnectionIdQuery& Query) + { + FBlueprintConnectionIdColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("a"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="OneConnectionId Where")) + static FOneConnectionIdQuery OneConnectionIdWhere(FOneConnectionIdQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="From OneEnumWithPayload")) + static FOneEnumWithPayloadQuery FromOneEnumWithPayload() + { + FOneEnumWithPayloadQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEnumWithPayload().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_enum_with_payload"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneEnumWithPayloadQueryToBlueprintQuery(const FOneEnumWithPayloadQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="OneEnumWithPayload Where")) + static FOneEnumWithPayloadQuery OneEnumWithPayloadWhere(FOneEnumWithPayloadQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="From OneEveryPrimitiveStruct")) + static FOneEveryPrimitiveStructQuery FromOneEveryPrimitiveStruct() + { + FOneEveryPrimitiveStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEveryPrimitiveStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_every_primitive_struct"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneEveryPrimitiveStructQueryToBlueprintQuery(const FOneEveryPrimitiveStructQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="OneEveryPrimitiveStruct Where")) + static FOneEveryPrimitiveStructQuery OneEveryPrimitiveStructWhere(FOneEveryPrimitiveStructQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="From OneEveryVecStruct")) + static FOneEveryVecStructQuery FromOneEveryVecStruct() + { + FOneEveryVecStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEveryVecStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_every_vec_struct"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneEveryVecStructQueryToBlueprintQuery(const FOneEveryVecStructQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="OneEveryVecStruct Where")) + static FOneEveryVecStructQuery OneEveryVecStructWhere(FOneEveryVecStructQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="From OneF32")) + static FOneF32Query FromOneF32() + { + FOneF32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneF32().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_f_32"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneF32QueryToBlueprintQuery(const FOneF32Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32|Columns", meta=(DisplayName="OneF32 F")) + static FBlueprintFloatColumn OneF32F(const FOneF32Query& Query) + { + FBlueprintFloatColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_f_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("f"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="OneF32 Where")) + static FOneF32Query OneF32Where(FOneF32Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="From OneF64")) + static FOneF64Query FromOneF64() + { + FOneF64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneF64().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_f_64"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneF64QueryToBlueprintQuery(const FOneF64Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64|Columns", meta=(DisplayName="OneF64 F")) + static FBlueprintDoubleColumn OneF64F(const FOneF64Query& Query) + { + FBlueprintDoubleColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_f_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("f"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="OneF64 Where")) + static FOneF64Query OneF64Where(FOneF64Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="From OneI128")) + static FOneI128Query FromOneI128() + { + FOneI128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI128().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_128"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI128QueryToBlueprintQuery(const FOneI128Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="OneI128 Where")) + static FOneI128Query OneI128Where(FOneI128Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="From OneI16")) + static FOneI16Query FromOneI16() + { + FOneI16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI16().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_16"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI16QueryToBlueprintQuery(const FOneI16Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="OneI16 Where")) + static FOneI16Query OneI16Where(FOneI16Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="From OneI256")) + static FOneI256Query FromOneI256() + { + FOneI256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI256().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_256"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI256QueryToBlueprintQuery(const FOneI256Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="OneI256 Where")) + static FOneI256Query OneI256Where(FOneI256Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="From OneI32")) + static FOneI32Query FromOneI32() + { + FOneI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_32"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI32QueryToBlueprintQuery(const FOneI32Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32|Columns", meta=(DisplayName="OneI32 N")) + static FBlueprintInt32Column OneI32N(const FOneI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="OneI32 Where")) + static FOneI32Query OneI32Where(FOneI32Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="From OneI64")) + static FOneI64Query FromOneI64() + { + FOneI64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI64().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_64"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI64QueryToBlueprintQuery(const FOneI64Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64|Columns", meta=(DisplayName="OneI64 N")) + static FBlueprintInt64Column OneI64N(const FOneI64Query& Query) + { + FBlueprintInt64Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="OneI64 Where")) + static FOneI64Query OneI64Where(FOneI64Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="From OneI8")) + static FOneI8Query FromOneI8() + { + FOneI8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI8().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_8"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI8QueryToBlueprintQuery(const FOneI8Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="OneI8 Where")) + static FOneI8Query OneI8Where(FOneI8Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="From OneIdentity")) + static FOneIdentityQuery FromOneIdentity() + { + FOneIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_identity"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneIdentityQueryToBlueprintQuery(const FOneIdentityQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity|Columns", meta=(DisplayName="OneIdentity I")) + static FBlueprintIdentityColumn OneIdentityI(const FOneIdentityQuery& Query) + { + FBlueprintIdentityColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_identity") : Query.ResultSourceName; + Column.ColumnName = TEXT("i"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="OneIdentity Where")) + static FOneIdentityQuery OneIdentityWhere(FOneIdentityQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="From OneSimpleEnum")) + static FOneSimpleEnumQuery FromOneSimpleEnum() + { + FOneSimpleEnumQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneSimpleEnum().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_simple_enum"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneSimpleEnumQueryToBlueprintQuery(const FOneSimpleEnumQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="OneSimpleEnum Where")) + static FOneSimpleEnumQuery OneSimpleEnumWhere(FOneSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="From OneString")) + static FOneStringQuery FromOneString() + { + FOneStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneString().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_string"); + return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable O")) - static FBlueprintDoubleColumn LargeTableO(const FLargeTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneStringQueryToBlueprintQuery(const FOneStringQuery& Query) { - FBlueprintDoubleColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; - Column.ColumnName = TEXT("o"); - return Column; + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable P")) - static FBlueprintStringColumn LargeTableP(const FLargeTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString|Columns", meta=(DisplayName="OneString S")) + static FBlueprintStringColumn OneStringS(const FOneStringQuery& Query) { FBlueprintStringColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; - Column.ColumnName = TEXT("p"); + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_string") : Query.ResultSourceName; + Column.ColumnName = TEXT("s"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable", meta=(DisplayName="LargeTable Where")) - static FLargeTableQuery LargeTableWhere(FLargeTableQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="OneString Where")) + static FOneStringQuery OneStringWhere(FOneStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19817,17 +24526,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="From OneBool")) - static FOneBoolQuery FromOneBool() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="From OneTimestamp")) + static FOneTimestampQuery FromOneTimestamp() { - FOneBoolQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneBool().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_bool"); + FOneTimestampQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneTimestamp().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_timestamp"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneBoolQueryToBlueprintQuery(const FOneBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneTimestampQueryToBlueprintQuery(const FOneTimestampQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19835,17 +24544,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool|Columns", meta=(DisplayName="OneBool B")) - static FBlueprintBoolColumn OneBoolB(const FOneBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp|Columns", meta=(DisplayName="OneTimestamp T")) + static FBlueprintTimestampColumn OneTimestampT(const FOneTimestampQuery& Query) { - FBlueprintBoolColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_bool") : Query.ResultSourceName; - Column.ColumnName = TEXT("b"); + FBlueprintTimestampColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_timestamp") : Query.ResultSourceName; + Column.ColumnName = TEXT("t"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="OneBool Where")) - static FOneBoolQuery OneBoolWhere(FOneBoolQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="OneTimestamp Where")) + static FOneTimestampQuery OneTimestampWhere(FOneTimestampQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19855,17 +24564,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="From OneByteStruct")) - static FOneByteStructQuery FromOneByteStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="From OneU128")) + static FOneU128Query FromOneU128() { - FOneByteStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneByteStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_byte_struct"); + FOneU128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU128().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneByteStructQueryToBlueprintQuery(const FOneByteStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU128QueryToBlueprintQuery(const FOneU128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19873,8 +24582,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="OneByteStruct Where")) - static FOneByteStructQuery OneByteStructWhere(FOneByteStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="OneU128 Where")) + static FOneU128Query OneU128Where(FOneU128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19884,17 +24593,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="From OneConnectionId")) - static FOneConnectionIdQuery FromOneConnectionId() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="From OneU16")) + static FOneU16Query FromOneU16() { - FOneConnectionIdQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneConnectionId().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_connection_id"); + FOneU16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU16().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneConnectionIdQueryToBlueprintQuery(const FOneConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU16QueryToBlueprintQuery(const FOneU16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19902,17 +24611,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId|Columns", meta=(DisplayName="OneConnectionId A")) - static FBlueprintConnectionIdColumn OneConnectionIdA(const FOneConnectionIdQuery& Query) - { - FBlueprintConnectionIdColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_connection_id") : Query.ResultSourceName; - Column.ColumnName = TEXT("a"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="OneConnectionId Where")) - static FOneConnectionIdQuery OneConnectionIdWhere(FOneConnectionIdQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="OneU16 Where")) + static FOneU16Query OneU16Where(FOneU16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19922,17 +24622,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="From OneEnumWithPayload")) - static FOneEnumWithPayloadQuery FromOneEnumWithPayload() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="From OneU256")) + static FOneU256Query FromOneU256() { - FOneEnumWithPayloadQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEnumWithPayload().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_enum_with_payload"); + FOneU256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU256().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneEnumWithPayloadQueryToBlueprintQuery(const FOneEnumWithPayloadQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU256QueryToBlueprintQuery(const FOneU256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19940,8 +24640,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="OneEnumWithPayload Where")) - static FOneEnumWithPayloadQuery OneEnumWithPayloadWhere(FOneEnumWithPayloadQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="OneU256 Where")) + static FOneU256Query OneU256Where(FOneU256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19951,17 +24651,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="From OneEveryPrimitiveStruct")) - static FOneEveryPrimitiveStructQuery FromOneEveryPrimitiveStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="From OneU32")) + static FOneU32Query FromOneU32() { - FOneEveryPrimitiveStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEveryPrimitiveStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_every_primitive_struct"); + FOneU32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU32().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneEveryPrimitiveStructQueryToBlueprintQuery(const FOneEveryPrimitiveStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU32QueryToBlueprintQuery(const FOneU32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19969,8 +24669,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="OneEveryPrimitiveStruct Where")) - static FOneEveryPrimitiveStructQuery OneEveryPrimitiveStructWhere(FOneEveryPrimitiveStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="OneU32 Where")) + static FOneU32Query OneU32Where(FOneU32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19980,17 +24680,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="From OneEveryVecStruct")) - static FOneEveryVecStructQuery FromOneEveryVecStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="From OneU64")) + static FOneU64Query FromOneU64() { - FOneEveryVecStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEveryVecStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_every_vec_struct"); + FOneU64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU64().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneEveryVecStructQueryToBlueprintQuery(const FOneEveryVecStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU64QueryToBlueprintQuery(const FOneU64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19998,8 +24698,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="OneEveryVecStruct Where")) - static FOneEveryVecStructQuery OneEveryVecStructWhere(FOneEveryVecStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="OneU64 Where")) + static FOneU64Query OneU64Where(FOneU64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20009,17 +24709,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="From OneF32")) - static FOneF32Query FromOneF32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="From OneU8")) + static FOneU8Query FromOneU8() { - FOneF32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneF32().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_f_32"); + FOneU8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU8().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneF32QueryToBlueprintQuery(const FOneF32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU8QueryToBlueprintQuery(const FOneU8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20027,17 +24727,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32|Columns", meta=(DisplayName="OneF32 F")) - static FBlueprintFloatColumn OneF32F(const FOneF32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8|Columns", meta=(DisplayName="OneU8 N")) + static FBlueprintUInt8Column OneU8N(const FOneU8Query& Query) { - FBlueprintFloatColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_f_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("f"); + FBlueprintUInt8Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_u_8") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="OneF32 Where")) - static FOneF32Query OneF32Where(FOneF32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="OneU8 Where")) + static FOneU8Query OneU8Where(FOneU8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20047,17 +24747,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="From OneF64")) - static FOneF64Query FromOneF64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="From OneUnitStruct")) + static FOneUnitStructQuery FromOneUnitStruct() { - FOneF64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneF64().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_f_64"); + FOneUnitStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneUnitStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_unit_struct"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneF64QueryToBlueprintQuery(const FOneF64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneUnitStructQueryToBlueprintQuery(const FOneUnitStructQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20065,17 +24765,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64|Columns", meta=(DisplayName="OneF64 F")) - static FBlueprintDoubleColumn OneF64F(const FOneF64Query& Query) - { - FBlueprintDoubleColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_f_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("f"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="OneF64 Where")) - static FOneF64Query OneF64Where(FOneF64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="OneUnitStruct Where")) + static FOneUnitStructQuery OneUnitStructWhere(FOneUnitStructQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20085,17 +24776,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="From OneI128")) - static FOneI128Query FromOneI128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="From OneUuid")) + static FOneUuidQuery FromOneUuid() { - FOneI128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI128().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_128"); + FOneUuidQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneUuid().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_uuid"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI128QueryToBlueprintQuery(const FOneI128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneUuidQueryToBlueprintQuery(const FOneUuidQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20103,8 +24794,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="OneI128 Where")) - static FOneI128Query OneI128Where(FOneI128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid|Columns", meta=(DisplayName="OneUuid U")) + static FBlueprintUuidColumn OneUuidU(const FOneUuidQuery& Query) + { + FBlueprintUuidColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_uuid") : Query.ResultSourceName; + Column.ColumnName = TEXT("u"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="OneUuid Where")) + static FOneUuidQuery OneUuidWhere(FOneUuidQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20114,17 +24814,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="From OneI16")) - static FOneI16Query FromOneI16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="From OptionEveryPrimitiveStruct")) + static FOptionEveryPrimitiveStructQuery FromOptionEveryPrimitiveStruct() { - FOneI16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI16().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_16"); + FOptionEveryPrimitiveStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionEveryPrimitiveStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_every_primitive_struct"); return Query; } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI16QueryToBlueprintQuery(const FOneI16Query& Query) + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionEveryPrimitiveStructQueryToBlueprintQuery(const FOptionEveryPrimitiveStructQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20132,8 +24832,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="OneI16 Where")) - static FOneI16Query OneI16Where(FOneI16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="OptionEveryPrimitiveStruct Where")) + static FOptionEveryPrimitiveStructQuery OptionEveryPrimitiveStructWhere(FOptionEveryPrimitiveStructQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20143,17 +24843,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="From OneI256")) - static FOneI256Query FromOneI256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="From OptionI32")) + static FOptionI32Query FromOptionI32() { - FOneI256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI256().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_256"); + FOptionI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI256QueryToBlueprintQuery(const FOneI256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionI32QueryToBlueprintQuery(const FOptionI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20161,8 +24861,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="OneI256 Where")) - static FOneI256Query OneI256Where(FOneI256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="OptionI32 Where")) + static FOptionI32Query OptionI32Where(FOptionI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20172,17 +24872,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="From OneI32")) - static FOneI32Query FromOneI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="From OptionIdentity")) + static FOptionIdentityQuery FromOptionIdentity() { - FOneI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_32"); + FOptionIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_identity"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI32QueryToBlueprintQuery(const FOneI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionIdentityQueryToBlueprintQuery(const FOptionIdentityQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20190,17 +24890,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32|Columns", meta=(DisplayName="OneI32 N")) - static FBlueprintInt32Column OneI32N(const FOneI32Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_i_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="OneI32 Where")) - static FOneI32Query OneI32Where(FOneI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="OptionIdentity Where")) + static FOptionIdentityQuery OptionIdentityWhere(FOptionIdentityQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20210,17 +24901,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="From OneI64")) - static FOneI64Query FromOneI64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="From OptionSimpleEnum")) + static FOptionSimpleEnumQuery FromOptionSimpleEnum() { - FOneI64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI64().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_64"); + FOptionSimpleEnumQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionSimpleEnum().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_simple_enum"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI64QueryToBlueprintQuery(const FOneI64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionSimpleEnumQueryToBlueprintQuery(const FOptionSimpleEnumQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20228,17 +24919,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64|Columns", meta=(DisplayName="OneI64 N")) - static FBlueprintInt64Column OneI64N(const FOneI64Query& Query) - { - FBlueprintInt64Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_i_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="OneI64 Where")) - static FOneI64Query OneI64Where(FOneI64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="OptionSimpleEnum Where")) + static FOptionSimpleEnumQuery OptionSimpleEnumWhere(FOptionSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20248,17 +24930,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="From OneI8")) - static FOneI8Query FromOneI8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="From OptionString")) + static FOptionStringQuery FromOptionString() { - FOneI8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI8().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_8"); + FOptionStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionString().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI8QueryToBlueprintQuery(const FOneI8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionStringQueryToBlueprintQuery(const FOptionStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20266,8 +24948,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="OneI8 Where")) - static FOneI8Query OneI8Where(FOneI8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="OptionString Where")) + static FOptionStringQuery OptionStringWhere(FOptionStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20277,17 +24959,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="From OneIdentity")) - static FOneIdentityQuery FromOneIdentity() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="From OptionUuid")) + static FOptionUuidQuery FromOptionUuid() { - FOneIdentityQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneIdentity().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_identity"); + FOptionUuidQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionUuid().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_uuid"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneIdentityQueryToBlueprintQuery(const FOneIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionUuidQueryToBlueprintQuery(const FOptionUuidQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20295,17 +24977,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity|Columns", meta=(DisplayName="OneIdentity I")) - static FBlueprintIdentityColumn OneIdentityI(const FOneIdentityQuery& Query) - { - FBlueprintIdentityColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_identity") : Query.ResultSourceName; - Column.ColumnName = TEXT("i"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="OneIdentity Where")) - static FOneIdentityQuery OneIdentityWhere(FOneIdentityQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="OptionUuid Where")) + static FOptionUuidQuery OptionUuidWhere(FOptionUuidQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20315,17 +24988,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="From OneSimpleEnum")) - static FOneSimpleEnumQuery FromOneSimpleEnum() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="From OptionVecOptionI32")) + static FOptionVecOptionI32Query FromOptionVecOptionI32() { - FOneSimpleEnumQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneSimpleEnum().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_simple_enum"); + FOptionVecOptionI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionVecOptionI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_vec_option_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneSimpleEnumQueryToBlueprintQuery(const FOneSimpleEnumQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionVecOptionI32QueryToBlueprintQuery(const FOptionVecOptionI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20333,8 +25006,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="OneSimpleEnum Where")) - static FOneSimpleEnumQuery OneSimpleEnumWhere(FOneSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="OptionVecOptionI32 Where")) + static FOptionVecOptionI32Query OptionVecOptionI32Where(FOptionVecOptionI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20344,17 +25017,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="From OneString")) - static FOneStringQuery FromOneString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="From PkBool")) + static FPkBoolQuery FromPkBool() { - FOneStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneString().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_string"); + FPkBoolQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkBool().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_bool"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneStringQueryToBlueprintQuery(const FOneStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkBoolQueryToBlueprintQuery(const FPkBoolQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20362,17 +25035,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString|Columns", meta=(DisplayName="OneString S")) - static FBlueprintStringColumn OneStringS(const FOneStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool|Columns", meta=(DisplayName="PkBool B")) + static FBlueprintBoolColumn PkBoolB(const FPkBoolQuery& Query) { - FBlueprintStringColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_string") : Query.ResultSourceName; - Column.ColumnName = TEXT("s"); + FBlueprintBoolColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("b"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="OneString Where")) - static FOneStringQuery OneStringWhere(FOneStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool|Columns", meta=(DisplayName="PkBool Data")) + static FBlueprintInt32Column PkBoolData(const FPkBoolQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="PkBool Where")) + static FPkBoolQuery PkBoolWhere(FPkBoolQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20382,17 +25064,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="From OneTimestamp")) - static FOneTimestampQuery FromOneTimestamp() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="From PkConnectionId")) + static FPkConnectionIdQuery FromPkConnectionId() { - FOneTimestampQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneTimestamp().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_timestamp"); + FPkConnectionIdQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkConnectionId().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_connection_id"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneTimestampQueryToBlueprintQuery(const FOneTimestampQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkConnectionIdQueryToBlueprintQuery(const FPkConnectionIdQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20400,17 +25082,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp|Columns", meta=(DisplayName="OneTimestamp T")) - static FBlueprintTimestampColumn OneTimestampT(const FOneTimestampQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId|Columns", meta=(DisplayName="PkConnectionId A")) + static FBlueprintConnectionIdColumn PkConnectionIdA(const FPkConnectionIdQuery& Query) { - FBlueprintTimestampColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_timestamp") : Query.ResultSourceName; - Column.ColumnName = TEXT("t"); + FBlueprintConnectionIdColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("a"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="OneTimestamp Where")) - static FOneTimestampQuery OneTimestampWhere(FOneTimestampQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId|Columns", meta=(DisplayName="PkConnectionId Data")) + static FBlueprintInt32Column PkConnectionIdData(const FPkConnectionIdQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="PkConnectionId Where")) + static FPkConnectionIdQuery PkConnectionIdWhere(FPkConnectionIdQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20420,17 +25111,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="From OneU128")) - static FOneU128Query FromOneU128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="From PkI128")) + static FPkI128Query FromPkI128() { - FOneU128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU128().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_128"); + FPkI128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI128().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU128QueryToBlueprintQuery(const FOneU128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI128QueryToBlueprintQuery(const FPkI128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20438,8 +25129,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="OneU128 Where")) - static FOneU128Query OneU128Where(FOneU128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128|Columns", meta=(DisplayName="PkI128 Data")) + static FBlueprintInt32Column PkI128Data(const FPkI128Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_128") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="PkI128 Where")) + static FPkI128Query PkI128Where(FPkI128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20449,17 +25149,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="From OneU16")) - static FOneU16Query FromOneU16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="From PkI16")) + static FPkI16Query FromPkI16() { - FOneU16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU16().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_16"); + FPkI16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI16().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_16"); return Query; } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU16QueryToBlueprintQuery(const FOneU16Query& Query) + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI16QueryToBlueprintQuery(const FPkI16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20467,8 +25167,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="OneU16 Where")) - static FOneU16Query OneU16Where(FOneU16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16|Columns", meta=(DisplayName="PkI16 Data")) + static FBlueprintInt32Column PkI16Data(const FPkI16Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_16") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="PkI16 Where")) + static FPkI16Query PkI16Where(FPkI16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20478,17 +25187,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="From OneU256")) - static FOneU256Query FromOneU256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="From PkI256")) + static FPkI256Query FromPkI256() { - FOneU256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU256().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_256"); + FPkI256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI256().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU256QueryToBlueprintQuery(const FOneU256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI256QueryToBlueprintQuery(const FPkI256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20496,8 +25205,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="OneU256 Where")) - static FOneU256Query OneU256Where(FOneU256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256|Columns", meta=(DisplayName="PkI256 Data")) + static FBlueprintInt32Column PkI256Data(const FPkI256Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_256") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="PkI256 Where")) + static FPkI256Query PkI256Where(FPkI256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20507,17 +25225,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="From OneU32")) - static FOneU32Query FromOneU32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="From PkI32")) + static FPkI32Query FromPkI32() { - FOneU32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU32().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_32"); + FPkI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU32QueryToBlueprintQuery(const FOneU32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI32QueryToBlueprintQuery(const FPkI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20525,8 +25243,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="OneU32 Where")) - static FOneU32Query OneU32Where(FOneU32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32|Columns", meta=(DisplayName="PkI32 N")) + static FBlueprintInt32Column PkI32N(const FPkI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32|Columns", meta=(DisplayName="PkI32 Data")) + static FBlueprintInt32Column PkI32Data(const FPkI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="PkI32 Where")) + static FPkI32Query PkI32Where(FPkI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20536,17 +25272,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="From OneU64")) - static FOneU64Query FromOneU64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="From PkI64")) + static FPkI64Query FromPkI64() { - FOneU64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU64().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_64"); + FPkI64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI64().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU64QueryToBlueprintQuery(const FOneU64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI64QueryToBlueprintQuery(const FPkI64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20554,8 +25290,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="OneU64 Where")) - static FOneU64Query OneU64Where(FOneU64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64|Columns", meta=(DisplayName="PkI64 N")) + static FBlueprintInt64Column PkI64N(const FPkI64Query& Query) + { + FBlueprintInt64Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64|Columns", meta=(DisplayName="PkI64 Data")) + static FBlueprintInt32Column PkI64Data(const FPkI64Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="PkI64 Where")) + static FPkI64Query PkI64Where(FPkI64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20565,17 +25319,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="From OneU8")) - static FOneU8Query FromOneU8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="From PkI8")) + static FPkI8Query FromPkI8() { - FOneU8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU8().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_8"); + FPkI8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI8().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU8QueryToBlueprintQuery(const FOneU8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI8QueryToBlueprintQuery(const FPkI8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20583,17 +25337,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8|Columns", meta=(DisplayName="OneU8 N")) - static FBlueprintUInt8Column OneU8N(const FOneU8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8|Columns", meta=(DisplayName="PkI8 Data")) + static FBlueprintInt32Column PkI8Data(const FPkI8Query& Query) { - FBlueprintUInt8Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_u_8") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_8") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="OneU8 Where")) - static FOneU8Query OneU8Where(FOneU8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="PkI8 Where")) + static FPkI8Query PkI8Where(FPkI8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20603,17 +25357,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="From OneUnitStruct")) - static FOneUnitStructQuery FromOneUnitStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="From PkIdentity")) + static FPkIdentityQuery FromPkIdentity() { - FOneUnitStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneUnitStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_unit_struct"); + FPkIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_identity"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneUnitStructQueryToBlueprintQuery(const FOneUnitStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkIdentityQueryToBlueprintQuery(const FPkIdentityQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20621,8 +25375,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="OneUnitStruct Where")) - static FOneUnitStructQuery OneUnitStructWhere(FOneUnitStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity|Columns", meta=(DisplayName="PkIdentity I")) + static FBlueprintIdentityColumn PkIdentityI(const FPkIdentityQuery& Query) + { + FBlueprintIdentityColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_identity") : Query.ResultSourceName; + Column.ColumnName = TEXT("i"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity|Columns", meta=(DisplayName="PkIdentity Data")) + static FBlueprintInt32Column PkIdentityData(const FPkIdentityQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_identity") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="PkIdentity Where")) + static FPkIdentityQuery PkIdentityWhere(FPkIdentityQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20632,17 +25404,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="From OneUuid")) - static FOneUuidQuery FromOneUuid() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="From PkSimpleEnum")) + static FPkSimpleEnumQuery FromPkSimpleEnum() { - FOneUuidQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneUuid().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_uuid"); + FPkSimpleEnumQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkSimpleEnum().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_simple_enum"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneUuidQueryToBlueprintQuery(const FOneUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkSimpleEnumQueryToBlueprintQuery(const FPkSimpleEnumQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20650,17 +25422,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid|Columns", meta=(DisplayName="OneUuid U")) - static FBlueprintUuidColumn OneUuidU(const FOneUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum|Columns", meta=(DisplayName="PkSimpleEnum Data")) + static FBlueprintInt32Column PkSimpleEnumData(const FPkSimpleEnumQuery& Query) { - FBlueprintUuidColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_uuid") : Query.ResultSourceName; - Column.ColumnName = TEXT("u"); + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_simple_enum") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="OneUuid Where")) - static FOneUuidQuery OneUuidWhere(FOneUuidQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="PkSimpleEnum Where")) + static FPkSimpleEnumQuery PkSimpleEnumWhere(FPkSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20670,17 +25442,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="From OptionEveryPrimitiveStruct")) - static FOptionEveryPrimitiveStructQuery FromOptionEveryPrimitiveStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="From PkString")) + static FPkStringQuery FromPkString() { - FOptionEveryPrimitiveStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionEveryPrimitiveStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_every_primitive_struct"); + FPkStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkString().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionEveryPrimitiveStructQueryToBlueprintQuery(const FOptionEveryPrimitiveStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkStringQueryToBlueprintQuery(const FPkStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20688,8 +25460,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="OptionEveryPrimitiveStruct Where")) - static FOptionEveryPrimitiveStructQuery OptionEveryPrimitiveStructWhere(FOptionEveryPrimitiveStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString|Columns", meta=(DisplayName="PkString S")) + static FBlueprintStringColumn PkStringS(const FPkStringQuery& Query) + { + FBlueprintStringColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_string") : Query.ResultSourceName; + Column.ColumnName = TEXT("s"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString|Columns", meta=(DisplayName="PkString Data")) + static FBlueprintInt32Column PkStringData(const FPkStringQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_string") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="PkString Where")) + static FPkStringQuery PkStringWhere(FPkStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20699,17 +25489,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="From OptionI32")) - static FOptionI32Query FromOptionI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="From PkU128")) + static FPkU128Query FromPkU128() { - FOptionI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_i_32"); + FPkU128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU128().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionI32QueryToBlueprintQuery(const FOptionI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU128QueryToBlueprintQuery(const FPkU128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20717,8 +25507,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="OptionI32 Where")) - static FOptionI32Query OptionI32Where(FOptionI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128|Columns", meta=(DisplayName="PkU128 Data")) + static FBlueprintInt32Column PkU128Data(const FPkU128Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_128") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="PkU128 Where")) + static FPkU128Query PkU128Where(FPkU128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20728,17 +25527,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="From OptionIdentity")) - static FOptionIdentityQuery FromOptionIdentity() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="From PkU16")) + static FPkU16Query FromPkU16() { - FOptionIdentityQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionIdentity().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_identity"); + FPkU16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU16().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionIdentityQueryToBlueprintQuery(const FOptionIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU16QueryToBlueprintQuery(const FPkU16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20746,8 +25545,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="OptionIdentity Where")) - static FOptionIdentityQuery OptionIdentityWhere(FOptionIdentityQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16|Columns", meta=(DisplayName="PkU16 Data")) + static FBlueprintInt32Column PkU16Data(const FPkU16Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_16") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="PkU16 Where")) + static FPkU16Query PkU16Where(FPkU16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20757,17 +25565,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="From OptionSimpleEnum")) - static FOptionSimpleEnumQuery FromOptionSimpleEnum() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="From PkU256")) + static FPkU256Query FromPkU256() { - FOptionSimpleEnumQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionSimpleEnum().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_simple_enum"); + FPkU256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU256().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionSimpleEnumQueryToBlueprintQuery(const FOptionSimpleEnumQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU256QueryToBlueprintQuery(const FPkU256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20775,8 +25583,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="OptionSimpleEnum Where")) - static FOptionSimpleEnumQuery OptionSimpleEnumWhere(FOptionSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256|Columns", meta=(DisplayName="PkU256 Data")) + static FBlueprintInt32Column PkU256Data(const FPkU256Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_256") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="PkU256 Where")) + static FPkU256Query PkU256Where(FPkU256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20786,17 +25603,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="From OptionString")) - static FOptionStringQuery FromOptionString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="From PkU32")) + static FPkU32Query FromPkU32() { - FOptionStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionString().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_string"); + FPkU32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU32().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionStringQueryToBlueprintQuery(const FOptionStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU32QueryToBlueprintQuery(const FPkU32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20804,8 +25621,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="OptionString Where")) - static FOptionStringQuery OptionStringWhere(FOptionStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32|Columns", meta=(DisplayName="PkU32 Data")) + static FBlueprintInt32Column PkU32Data(const FPkU32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="PkU32 Where")) + static FPkU32Query PkU32Where(FPkU32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20815,17 +25641,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="From OptionUuid")) - static FOptionUuidQuery FromOptionUuid() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="From PkU32Two")) + static FPkU32TwoQuery FromPkU32Two() { - FOptionUuidQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionUuid().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_uuid"); + FPkU32TwoQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU32Two().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_32_two"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionUuidQueryToBlueprintQuery(const FOptionUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU32TwoQueryToBlueprintQuery(const FPkU32TwoQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20833,8 +25659,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="OptionUuid Where")) - static FOptionUuidQuery OptionUuidWhere(FOptionUuidQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two|Columns", meta=(DisplayName="PkU32Two Data")) + static FBlueprintInt32Column PkU32TwoData(const FPkU32TwoQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_32_two") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="PkU32Two Where")) + static FPkU32TwoQuery PkU32TwoWhere(FPkU32TwoQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20844,17 +25679,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="From OptionVecOptionI32")) - static FOptionVecOptionI32Query FromOptionVecOptionI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="From PkU64")) + static FPkU64Query FromPkU64() { - FOptionVecOptionI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionVecOptionI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_vec_option_i_32"); + FPkU64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU64().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionVecOptionI32QueryToBlueprintQuery(const FOptionVecOptionI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU64QueryToBlueprintQuery(const FPkU64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20862,8 +25697,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="OptionVecOptionI32 Where")) - static FOptionVecOptionI32Query OptionVecOptionI32Where(FOptionVecOptionI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64|Columns", meta=(DisplayName="PkU64 Data")) + static FBlueprintInt32Column PkU64Data(const FPkU64Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="PkU64 Where")) + static FPkU64Query PkU64Where(FPkU64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20873,17 +25717,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="From PkBool")) - static FPkBoolQuery FromPkBool() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="From PkU8")) + static FPkU8Query FromPkU8() { - FPkBoolQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkBool().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_bool"); + FPkU8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU8().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkBoolQueryToBlueprintQuery(const FPkBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU8QueryToBlueprintQuery(const FPkU8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20891,26 +25735,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool|Columns", meta=(DisplayName="PkBool B")) - static FBlueprintBoolColumn PkBoolB(const FPkBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8|Columns", meta=(DisplayName="PkU8 N")) + static FBlueprintUInt8Column PkU8N(const FPkU8Query& Query) { - FBlueprintBoolColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_bool") : Query.ResultSourceName; - Column.ColumnName = TEXT("b"); + FBlueprintUInt8Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_8") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool|Columns", meta=(DisplayName="PkBool Data")) - static FBlueprintInt32Column PkBoolData(const FPkBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8|Columns", meta=(DisplayName="PkU8 Data")) + static FBlueprintInt32Column PkU8Data(const FPkU8Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_bool") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_8") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="PkBool Where")) - static FPkBoolQuery PkBoolWhere(FPkBoolQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="PkU8 Where")) + static FPkU8Query PkU8Where(FPkU8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20920,17 +25764,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="From PkConnectionId")) - static FPkConnectionIdQuery FromPkConnectionId() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="From PkUuid")) + static FPkUuidQuery FromPkUuid() { - FPkConnectionIdQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkConnectionId().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_connection_id"); + FPkUuidQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkUuid().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_uuid"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkConnectionIdQueryToBlueprintQuery(const FPkConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkUuidQueryToBlueprintQuery(const FPkUuidQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20938,26 +25782,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId|Columns", meta=(DisplayName="PkConnectionId A")) - static FBlueprintConnectionIdColumn PkConnectionIdA(const FPkConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid|Columns", meta=(DisplayName="PkUuid U")) + static FBlueprintUuidColumn PkUuidU(const FPkUuidQuery& Query) { - FBlueprintConnectionIdColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_connection_id") : Query.ResultSourceName; - Column.ColumnName = TEXT("a"); + FBlueprintUuidColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_uuid") : Query.ResultSourceName; + Column.ColumnName = TEXT("u"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId|Columns", meta=(DisplayName="PkConnectionId Data")) - static FBlueprintInt32Column PkConnectionIdData(const FPkConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid|Columns", meta=(DisplayName="PkUuid Data")) + static FBlueprintInt32Column PkUuidData(const FPkUuidQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_connection_id") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_uuid") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="PkConnectionId Where")) - static FPkConnectionIdQuery PkConnectionIdWhere(FPkConnectionIdQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="PkUuid Where")) + static FPkUuidQuery PkUuidWhere(FPkUuidQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20967,17 +25811,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="From PkI128")) - static FPkI128Query FromPkI128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="From ResultEveryPrimitiveStructString")) + static FResultEveryPrimitiveStructStringQuery FromResultEveryPrimitiveStructString() { - FPkI128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI128().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_128"); + FResultEveryPrimitiveStructStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultEveryPrimitiveStructString().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_every_primitive_struct_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI128QueryToBlueprintQuery(const FPkI128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultEveryPrimitiveStructStringQueryToBlueprintQuery(const FResultEveryPrimitiveStructStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20985,17 +25829,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128|Columns", meta=(DisplayName="PkI128 Data")) - static FBlueprintInt32Column PkI128Data(const FPkI128Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_128") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="PkI128 Where")) - static FPkI128Query PkI128Where(FPkI128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="ResultEveryPrimitiveStructString Where")) + static FResultEveryPrimitiveStructStringQuery ResultEveryPrimitiveStructStringWhere(FResultEveryPrimitiveStructStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21005,17 +25840,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="From PkI16")) - static FPkI16Query FromPkI16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="From ResultI32String")) + static FResultI32StringQuery FromResultI32String() { - FPkI16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI16().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_16"); + FResultI32StringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultI32String().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_i_32_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI16QueryToBlueprintQuery(const FPkI16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultI32StringQueryToBlueprintQuery(const FResultI32StringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21023,17 +25858,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16|Columns", meta=(DisplayName="PkI16 Data")) - static FBlueprintInt32Column PkI16Data(const FPkI16Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_16") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="PkI16 Where")) - static FPkI16Query PkI16Where(FPkI16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="ResultI32String Where")) + static FResultI32StringQuery ResultI32StringWhere(FResultI32StringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21043,17 +25869,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="From PkI256")) - static FPkI256Query FromPkI256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="From ResultIdentityString")) + static FResultIdentityStringQuery FromResultIdentityString() { - FPkI256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI256().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_256"); + FResultIdentityStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultIdentityString().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_identity_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI256QueryToBlueprintQuery(const FPkI256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultIdentityStringQueryToBlueprintQuery(const FResultIdentityStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21061,17 +25887,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256|Columns", meta=(DisplayName="PkI256 Data")) - static FBlueprintInt32Column PkI256Data(const FPkI256Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_256") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="PkI256 Where")) - static FPkI256Query PkI256Where(FPkI256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="ResultIdentityString Where")) + static FResultIdentityStringQuery ResultIdentityStringWhere(FResultIdentityStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21081,17 +25898,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="From PkI32")) - static FPkI32Query FromPkI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="From ResultSimpleEnumI32")) + static FResultSimpleEnumI32Query FromResultSimpleEnumI32() { - FPkI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_32"); + FResultSimpleEnumI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultSimpleEnumI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_simple_enum_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI32QueryToBlueprintQuery(const FPkI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultSimpleEnumI32QueryToBlueprintQuery(const FResultSimpleEnumI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21099,26 +25916,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32|Columns", meta=(DisplayName="PkI32 N")) - static FBlueprintInt32Column PkI32N(const FPkI32Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32|Columns", meta=(DisplayName="PkI32 Data")) - static FBlueprintInt32Column PkI32Data(const FPkI32Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="PkI32 Where")) - static FPkI32Query PkI32Where(FPkI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="ResultSimpleEnumI32 Where")) + static FResultSimpleEnumI32Query ResultSimpleEnumI32Where(FResultSimpleEnumI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21128,17 +25927,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="From PkI64")) - static FPkI64Query FromPkI64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="From ResultStringI32")) + static FResultStringI32Query FromResultStringI32() { - FPkI64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI64().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_64"); + FResultStringI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultStringI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_string_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI64QueryToBlueprintQuery(const FPkI64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultStringI32QueryToBlueprintQuery(const FResultStringI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21146,26 +25945,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64|Columns", meta=(DisplayName="PkI64 N")) - static FBlueprintInt64Column PkI64N(const FPkI64Query& Query) - { - FBlueprintInt64Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64|Columns", meta=(DisplayName="PkI64 Data")) - static FBlueprintInt32Column PkI64Data(const FPkI64Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="PkI64 Where")) - static FPkI64Query PkI64Where(FPkI64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="ResultStringI32 Where")) + static FResultStringI32Query ResultStringI32Where(FResultStringI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21175,17 +25956,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="From PkI8")) - static FPkI8Query FromPkI8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="From ResultVecI32String")) + static FResultVecI32StringQuery FromResultVecI32String() { - FPkI8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI8().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_8"); + FResultVecI32StringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultVecI32String().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_vec_i_32_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI8QueryToBlueprintQuery(const FPkI8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultVecI32StringQueryToBlueprintQuery(const FResultVecI32StringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21193,17 +25974,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8|Columns", meta=(DisplayName="PkI8 Data")) - static FBlueprintInt32Column PkI8Data(const FPkI8Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_8") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="PkI8 Where")) - static FPkI8Query PkI8Where(FPkI8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="ResultVecI32String Where")) + static FResultVecI32StringQuery ResultVecI32StringWhere(FResultVecI32StringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21213,17 +25985,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="From PkIdentity")) - static FPkIdentityQuery FromPkIdentity() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="From ScheduledTable")) + static FScheduledTableQuery FromScheduledTable() { - FPkIdentityQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkIdentity().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_identity"); + FScheduledTableQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ScheduledTable().into_sql().c_str())); + Query.ResultSourceName = TEXT("scheduled_table"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkIdentityQueryToBlueprintQuery(const FPkIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ScheduledTableQueryToBlueprintQuery(const FScheduledTableQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21231,26 +26003,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity|Columns", meta=(DisplayName="PkIdentity I")) - static FBlueprintIdentityColumn PkIdentityI(const FPkIdentityQuery& Query) - { - FBlueprintIdentityColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_identity") : Query.ResultSourceName; - Column.ColumnName = TEXT("i"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity|Columns", meta=(DisplayName="PkIdentity Data")) - static FBlueprintInt32Column PkIdentityData(const FPkIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable|Columns", meta=(DisplayName="ScheduledTable Text")) + static FBlueprintStringColumn ScheduledTableText(const FScheduledTableQuery& Query) { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_identity") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); + FBlueprintStringColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("scheduled_table") : Query.ResultSourceName; + Column.ColumnName = TEXT("text"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="PkIdentity Where")) - static FPkIdentityQuery PkIdentityWhere(FPkIdentityQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="ScheduledTable Where")) + static FScheduledTableQuery ScheduledTableWhere(FScheduledTableQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21260,17 +26023,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="From PkSimpleEnum")) - static FPkSimpleEnumQuery FromPkSimpleEnum() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="From TableHoldsTable")) + static FTableHoldsTableQuery FromTableHoldsTable() { - FPkSimpleEnumQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkSimpleEnum().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_simple_enum"); + FTableHoldsTableQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.TableHoldsTable().into_sql().c_str())); + Query.ResultSourceName = TEXT("table_holds_table"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkSimpleEnumQueryToBlueprintQuery(const FPkSimpleEnumQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_TableHoldsTableQueryToBlueprintQuery(const FTableHoldsTableQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21278,17 +26041,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum|Columns", meta=(DisplayName="PkSimpleEnum Data")) - static FBlueprintInt32Column PkSimpleEnumData(const FPkSimpleEnumQuery& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_simple_enum") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="PkSimpleEnum Where")) - static FPkSimpleEnumQuery PkSimpleEnumWhere(FPkSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="TableHoldsTable Where")) + static FTableHoldsTableQuery TableHoldsTableWhere(FTableHoldsTableQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21298,17 +26052,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="From PkString")) - static FPkStringQuery FromPkString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="From UniqueBool")) + static FUniqueBoolQuery FromUniqueBool() { - FPkStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkString().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_string"); + FUniqueBoolQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueBool().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_bool"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkStringQueryToBlueprintQuery(const FPkStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueBoolQueryToBlueprintQuery(const FUniqueBoolQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21316,26 +26070,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString|Columns", meta=(DisplayName="PkString S")) - static FBlueprintStringColumn PkStringS(const FPkStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool|Columns", meta=(DisplayName="UniqueBool B")) + static FBlueprintBoolColumn UniqueBoolB(const FUniqueBoolQuery& Query) { - FBlueprintStringColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_string") : Query.ResultSourceName; - Column.ColumnName = TEXT("s"); + FBlueprintBoolColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("b"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString|Columns", meta=(DisplayName="PkString Data")) - static FBlueprintInt32Column PkStringData(const FPkStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool|Columns", meta=(DisplayName="UniqueBool Data")) + static FBlueprintInt32Column UniqueBoolData(const FUniqueBoolQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_string") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_bool") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="PkString Where")) - static FPkStringQuery PkStringWhere(FPkStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="UniqueBool Where")) + static FUniqueBoolQuery UniqueBoolWhere(FUniqueBoolQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21345,17 +26099,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="From PkU128")) - static FPkU128Query FromPkU128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="From UniqueConnectionId")) + static FUniqueConnectionIdQuery FromUniqueConnectionId() { - FPkU128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU128().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_128"); + FUniqueConnectionIdQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueConnectionId().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_connection_id"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU128QueryToBlueprintQuery(const FPkU128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueConnectionIdQueryToBlueprintQuery(const FUniqueConnectionIdQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21363,17 +26117,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128|Columns", meta=(DisplayName="PkU128 Data")) - static FBlueprintInt32Column PkU128Data(const FPkU128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId|Columns", meta=(DisplayName="UniqueConnectionId A")) + static FBlueprintConnectionIdColumn UniqueConnectionIdA(const FUniqueConnectionIdQuery& Query) + { + FBlueprintConnectionIdColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("a"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId|Columns", meta=(DisplayName="UniqueConnectionId Data")) + static FBlueprintInt32Column UniqueConnectionIdData(const FUniqueConnectionIdQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_128") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_connection_id") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="PkU128 Where")) - static FPkU128Query PkU128Where(FPkU128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="UniqueConnectionId Where")) + static FUniqueConnectionIdQuery UniqueConnectionIdWhere(FUniqueConnectionIdQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21383,17 +26146,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="From PkU16")) - static FPkU16Query FromPkU16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="From UniqueI128")) + static FUniqueI128Query FromUniqueI128() { - FPkU16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU16().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_16"); + FUniqueI128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI128().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU16QueryToBlueprintQuery(const FPkU16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI128QueryToBlueprintQuery(const FUniqueI128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21401,17 +26164,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16|Columns", meta=(DisplayName="PkU16 Data")) - static FBlueprintInt32Column PkU16Data(const FPkU16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128|Columns", meta=(DisplayName="UniqueI128 Data")) + static FBlueprintInt32Column UniqueI128Data(const FUniqueI128Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_16") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_128") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="PkU16 Where")) - static FPkU16Query PkU16Where(FPkU16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="UniqueI128 Where")) + static FUniqueI128Query UniqueI128Where(FUniqueI128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21421,17 +26184,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="From PkU256")) - static FPkU256Query FromPkU256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="From UniqueI16")) + static FUniqueI16Query FromUniqueI16() { - FPkU256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU256().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_256"); + FUniqueI16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI16().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU256QueryToBlueprintQuery(const FPkU256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI16QueryToBlueprintQuery(const FUniqueI16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21439,17 +26202,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256|Columns", meta=(DisplayName="PkU256 Data")) - static FBlueprintInt32Column PkU256Data(const FPkU256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16|Columns", meta=(DisplayName="UniqueI16 Data")) + static FBlueprintInt32Column UniqueI16Data(const FUniqueI16Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_256") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_16") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="PkU256 Where")) - static FPkU256Query PkU256Where(FPkU256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="UniqueI16 Where")) + static FUniqueI16Query UniqueI16Where(FUniqueI16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21459,17 +26222,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="From PkU32")) - static FPkU32Query FromPkU32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="From UniqueI256")) + static FUniqueI256Query FromUniqueI256() { - FPkU32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU32().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_32"); + FUniqueI256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI256().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU32QueryToBlueprintQuery(const FPkU32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI256QueryToBlueprintQuery(const FUniqueI256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21477,17 +26240,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32|Columns", meta=(DisplayName="PkU32 Data")) - static FBlueprintInt32Column PkU32Data(const FPkU32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256|Columns", meta=(DisplayName="UniqueI256 Data")) + static FBlueprintInt32Column UniqueI256Data(const FUniqueI256Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_32") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_256") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="PkU32 Where")) - static FPkU32Query PkU32Where(FPkU32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="UniqueI256 Where")) + static FUniqueI256Query UniqueI256Where(FUniqueI256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21497,17 +26260,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="From PkU32Two")) - static FPkU32TwoQuery FromPkU32Two() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="From UniqueI32")) + static FUniqueI32Query FromUniqueI32() { - FPkU32TwoQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU32Two().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_32_two"); + FUniqueI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU32TwoQueryToBlueprintQuery(const FPkU32TwoQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI32QueryToBlueprintQuery(const FUniqueI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21515,17 +26278,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two|Columns", meta=(DisplayName="PkU32Two Data")) - static FBlueprintInt32Column PkU32TwoData(const FPkU32TwoQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32|Columns", meta=(DisplayName="UniqueI32 N")) + static FBlueprintInt32Column UniqueI32N(const FUniqueI32Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_32_two") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32|Columns", meta=(DisplayName="UniqueI32 Data")) + static FBlueprintInt32Column UniqueI32Data(const FUniqueI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_32") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="PkU32Two Where")) - static FPkU32TwoQuery PkU32TwoWhere(FPkU32TwoQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="UniqueI32 Where")) + static FUniqueI32Query UniqueI32Where(FUniqueI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21535,17 +26307,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="From PkU64")) - static FPkU64Query FromPkU64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="From UniqueI64")) + static FUniqueI64Query FromUniqueI64() { - FPkU64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU64().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_64"); + FUniqueI64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI64().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU64QueryToBlueprintQuery(const FPkU64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI64QueryToBlueprintQuery(const FUniqueI64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21553,17 +26325,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64|Columns", meta=(DisplayName="PkU64 Data")) - static FBlueprintInt32Column PkU64Data(const FPkU64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64|Columns", meta=(DisplayName="UniqueI64 N")) + static FBlueprintInt64Column UniqueI64N(const FUniqueI64Query& Query) + { + FBlueprintInt64Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64|Columns", meta=(DisplayName="UniqueI64 Data")) + static FBlueprintInt32Column UniqueI64Data(const FUniqueI64Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_64") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_64") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="PkU64 Where")) - static FPkU64Query PkU64Where(FPkU64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="UniqueI64 Where")) + static FUniqueI64Query UniqueI64Where(FUniqueI64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21573,17 +26354,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="From PkU8")) - static FPkU8Query FromPkU8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="From UniqueI8")) + static FUniqueI8Query FromUniqueI8() { - FPkU8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU8().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_8"); + FUniqueI8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI8().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU8QueryToBlueprintQuery(const FPkU8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI8QueryToBlueprintQuery(const FUniqueI8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21591,26 +26372,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8|Columns", meta=(DisplayName="PkU8 N")) - static FBlueprintUInt8Column PkU8N(const FPkU8Query& Query) - { - FBlueprintUInt8Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_8") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8|Columns", meta=(DisplayName="PkU8 Data")) - static FBlueprintInt32Column PkU8Data(const FPkU8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8|Columns", meta=(DisplayName="UniqueI8 Data")) + static FBlueprintInt32Column UniqueI8Data(const FUniqueI8Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_8") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_8") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="PkU8 Where")) - static FPkU8Query PkU8Where(FPkU8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="UniqueI8 Where")) + static FUniqueI8Query UniqueI8Where(FUniqueI8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21620,17 +26392,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="From PkUuid")) - static FPkUuidQuery FromPkUuid() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="From UniqueIdentity")) + static FUniqueIdentityQuery FromUniqueIdentity() { - FPkUuidQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkUuid().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_uuid"); + FUniqueIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_identity"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkUuidQueryToBlueprintQuery(const FPkUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueIdentityQueryToBlueprintQuery(const FUniqueIdentityQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21638,26 +26410,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid|Columns", meta=(DisplayName="PkUuid U")) - static FBlueprintUuidColumn PkUuidU(const FPkUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity|Columns", meta=(DisplayName="UniqueIdentity I")) + static FBlueprintIdentityColumn UniqueIdentityI(const FUniqueIdentityQuery& Query) { - FBlueprintUuidColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_uuid") : Query.ResultSourceName; - Column.ColumnName = TEXT("u"); + FBlueprintIdentityColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_identity") : Query.ResultSourceName; + Column.ColumnName = TEXT("i"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid|Columns", meta=(DisplayName="PkUuid Data")) - static FBlueprintInt32Column PkUuidData(const FPkUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity|Columns", meta=(DisplayName="UniqueIdentity Data")) + static FBlueprintInt32Column UniqueIdentityData(const FUniqueIdentityQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_uuid") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_identity") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="PkUuid Where")) - static FPkUuidQuery PkUuidWhere(FPkUuidQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="UniqueIdentity Where")) + static FUniqueIdentityQuery UniqueIdentityWhere(FUniqueIdentityQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21667,17 +26439,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="From ResultEveryPrimitiveStructString")) - static FResultEveryPrimitiveStructStringQuery FromResultEveryPrimitiveStructString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionBool", meta=(DisplayName="From UniqueOptionBool")) + static FUniqueOptionBoolQuery FromUniqueOptionBool() { - FResultEveryPrimitiveStructStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultEveryPrimitiveStructString().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_every_primitive_struct_string"); + FUniqueOptionBoolQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionBool().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_bool"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultEveryPrimitiveStructStringQueryToBlueprintQuery(const FResultEveryPrimitiveStructStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionBool", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionBoolQueryToBlueprintQuery(const FUniqueOptionBoolQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21685,8 +26457,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="ResultEveryPrimitiveStructString Where")) - static FResultEveryPrimitiveStructStringQuery ResultEveryPrimitiveStructStringWhere(FResultEveryPrimitiveStructStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionBool|Columns", meta=(DisplayName="UniqueOptionBool Data")) + static FBlueprintInt32Column UniqueOptionBoolData(const FUniqueOptionBoolQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionBool", meta=(DisplayName="UniqueOptionBool Where")) + static FUniqueOptionBoolQuery UniqueOptionBoolWhere(FUniqueOptionBoolQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21696,17 +26477,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="From ResultI32String")) - static FResultI32StringQuery FromResultI32String() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionConnectionId", meta=(DisplayName="From UniqueOptionConnectionId")) + static FUniqueOptionConnectionIdQuery FromUniqueOptionConnectionId() { - FResultI32StringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultI32String().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_i_32_string"); + FUniqueOptionConnectionIdQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionConnectionId().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_connection_id"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultI32StringQueryToBlueprintQuery(const FResultI32StringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionConnectionIdQueryToBlueprintQuery(const FUniqueOptionConnectionIdQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21714,8 +26495,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="ResultI32String Where")) - static FResultI32StringQuery ResultI32StringWhere(FResultI32StringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionConnectionId|Columns", meta=(DisplayName="UniqueOptionConnectionId Data")) + static FBlueprintInt32Column UniqueOptionConnectionIdData(const FUniqueOptionConnectionIdQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionConnectionId", meta=(DisplayName="UniqueOptionConnectionId Where")) + static FUniqueOptionConnectionIdQuery UniqueOptionConnectionIdWhere(FUniqueOptionConnectionIdQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21725,17 +26515,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="From ResultIdentityString")) - static FResultIdentityStringQuery FromResultIdentityString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI128", meta=(DisplayName="From UniqueOptionI128")) + static FUniqueOptionI128Query FromUniqueOptionI128() { - FResultIdentityStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultIdentityString().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_identity_string"); + FUniqueOptionI128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI128().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultIdentityStringQueryToBlueprintQuery(const FResultIdentityStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI128QueryToBlueprintQuery(const FUniqueOptionI128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21743,8 +26533,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="ResultIdentityString Where")) - static FResultIdentityStringQuery ResultIdentityStringWhere(FResultIdentityStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI128|Columns", meta=(DisplayName="UniqueOptionI128 Data")) + static FBlueprintInt32Column UniqueOptionI128Data(const FUniqueOptionI128Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_128") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI128", meta=(DisplayName="UniqueOptionI128 Where")) + static FUniqueOptionI128Query UniqueOptionI128Where(FUniqueOptionI128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21754,17 +26553,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="From ResultSimpleEnumI32")) - static FResultSimpleEnumI32Query FromResultSimpleEnumI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI16", meta=(DisplayName="From UniqueOptionI16")) + static FUniqueOptionI16Query FromUniqueOptionI16() { - FResultSimpleEnumI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultSimpleEnumI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_simple_enum_i_32"); + FUniqueOptionI16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI16().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultSimpleEnumI32QueryToBlueprintQuery(const FResultSimpleEnumI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI16QueryToBlueprintQuery(const FUniqueOptionI16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21772,8 +26571,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="ResultSimpleEnumI32 Where")) - static FResultSimpleEnumI32Query ResultSimpleEnumI32Where(FResultSimpleEnumI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI16|Columns", meta=(DisplayName="UniqueOptionI16 Data")) + static FBlueprintInt32Column UniqueOptionI16Data(const FUniqueOptionI16Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_16") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI16", meta=(DisplayName="UniqueOptionI16 Where")) + static FUniqueOptionI16Query UniqueOptionI16Where(FUniqueOptionI16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21783,17 +26591,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="From ResultStringI32")) - static FResultStringI32Query FromResultStringI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI256", meta=(DisplayName="From UniqueOptionI256")) + static FUniqueOptionI256Query FromUniqueOptionI256() { - FResultStringI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultStringI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_string_i_32"); + FUniqueOptionI256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI256().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultStringI32QueryToBlueprintQuery(const FResultStringI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI256QueryToBlueprintQuery(const FUniqueOptionI256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21801,8 +26609,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="ResultStringI32 Where")) - static FResultStringI32Query ResultStringI32Where(FResultStringI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI256|Columns", meta=(DisplayName="UniqueOptionI256 Data")) + static FBlueprintInt32Column UniqueOptionI256Data(const FUniqueOptionI256Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_256") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI256", meta=(DisplayName="UniqueOptionI256 Where")) + static FUniqueOptionI256Query UniqueOptionI256Where(FUniqueOptionI256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21812,17 +26629,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="From ResultVecI32String")) - static FResultVecI32StringQuery FromResultVecI32String() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI32", meta=(DisplayName="From UniqueOptionI32")) + static FUniqueOptionI32Query FromUniqueOptionI32() { - FResultVecI32StringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultVecI32String().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_vec_i_32_string"); + FUniqueOptionI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultVecI32StringQueryToBlueprintQuery(const FResultVecI32StringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI32QueryToBlueprintQuery(const FUniqueOptionI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21830,8 +26647,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="ResultVecI32String Where")) - static FResultVecI32StringQuery ResultVecI32StringWhere(FResultVecI32StringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI32|Columns", meta=(DisplayName="UniqueOptionI32 Data")) + static FBlueprintInt32Column UniqueOptionI32Data(const FUniqueOptionI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI32", meta=(DisplayName="UniqueOptionI32 Where")) + static FUniqueOptionI32Query UniqueOptionI32Where(FUniqueOptionI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21841,17 +26667,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="From ScheduledTable")) - static FScheduledTableQuery FromScheduledTable() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI64", meta=(DisplayName="From UniqueOptionI64")) + static FUniqueOptionI64Query FromUniqueOptionI64() { - FScheduledTableQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ScheduledTable().into_sql().c_str())); - Query.ResultSourceName = TEXT("scheduled_table"); + FUniqueOptionI64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI64().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ScheduledTableQueryToBlueprintQuery(const FScheduledTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI64QueryToBlueprintQuery(const FUniqueOptionI64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21859,17 +26685,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable|Columns", meta=(DisplayName="ScheduledTable Text")) - static FBlueprintStringColumn ScheduledTableText(const FScheduledTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI64|Columns", meta=(DisplayName="UniqueOptionI64 Data")) + static FBlueprintInt32Column UniqueOptionI64Data(const FUniqueOptionI64Query& Query) { - FBlueprintStringColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("scheduled_table") : Query.ResultSourceName; - Column.ColumnName = TEXT("text"); + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="ScheduledTable Where")) - static FScheduledTableQuery ScheduledTableWhere(FScheduledTableQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI64", meta=(DisplayName="UniqueOptionI64 Where")) + static FUniqueOptionI64Query UniqueOptionI64Where(FUniqueOptionI64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21879,17 +26705,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="From TableHoldsTable")) - static FTableHoldsTableQuery FromTableHoldsTable() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI8", meta=(DisplayName="From UniqueOptionI8")) + static FUniqueOptionI8Query FromUniqueOptionI8() { - FTableHoldsTableQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.TableHoldsTable().into_sql().c_str())); - Query.ResultSourceName = TEXT("table_holds_table"); + FUniqueOptionI8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI8().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_TableHoldsTableQueryToBlueprintQuery(const FTableHoldsTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI8QueryToBlueprintQuery(const FUniqueOptionI8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21897,8 +26723,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="TableHoldsTable Where")) - static FTableHoldsTableQuery TableHoldsTableWhere(FTableHoldsTableQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI8|Columns", meta=(DisplayName="UniqueOptionI8 Data")) + static FBlueprintInt32Column UniqueOptionI8Data(const FUniqueOptionI8Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_8") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI8", meta=(DisplayName="UniqueOptionI8 Where")) + static FUniqueOptionI8Query UniqueOptionI8Where(FUniqueOptionI8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21908,17 +26743,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="From UniqueBool")) - static FUniqueBoolQuery FromUniqueBool() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionIdentity", meta=(DisplayName="From UniqueOptionIdentity")) + static FUniqueOptionIdentityQuery FromUniqueOptionIdentity() { - FUniqueBoolQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueBool().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_bool"); + FUniqueOptionIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_identity"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueBoolQueryToBlueprintQuery(const FUniqueBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionIdentityQueryToBlueprintQuery(const FUniqueOptionIdentityQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21926,26 +26761,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool|Columns", meta=(DisplayName="UniqueBool B")) - static FBlueprintBoolColumn UniqueBoolB(const FUniqueBoolQuery& Query) - { - FBlueprintBoolColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_bool") : Query.ResultSourceName; - Column.ColumnName = TEXT("b"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool|Columns", meta=(DisplayName="UniqueBool Data")) - static FBlueprintInt32Column UniqueBoolData(const FUniqueBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionIdentity|Columns", meta=(DisplayName="UniqueOptionIdentity Data")) + static FBlueprintInt32Column UniqueOptionIdentityData(const FUniqueOptionIdentityQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_bool") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_identity") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="UniqueBool Where")) - static FUniqueBoolQuery UniqueBoolWhere(FUniqueBoolQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionIdentity", meta=(DisplayName="UniqueOptionIdentity Where")) + static FUniqueOptionIdentityQuery UniqueOptionIdentityWhere(FUniqueOptionIdentityQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21955,17 +26781,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="From UniqueConnectionId")) - static FUniqueConnectionIdQuery FromUniqueConnectionId() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionString", meta=(DisplayName="From UniqueOptionString")) + static FUniqueOptionStringQuery FromUniqueOptionString() { - FUniqueConnectionIdQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueConnectionId().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_connection_id"); + FUniqueOptionStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionString().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueConnectionIdQueryToBlueprintQuery(const FUniqueConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionStringQueryToBlueprintQuery(const FUniqueOptionStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21973,26 +26799,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId|Columns", meta=(DisplayName="UniqueConnectionId A")) - static FBlueprintConnectionIdColumn UniqueConnectionIdA(const FUniqueConnectionIdQuery& Query) - { - FBlueprintConnectionIdColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_connection_id") : Query.ResultSourceName; - Column.ColumnName = TEXT("a"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId|Columns", meta=(DisplayName="UniqueConnectionId Data")) - static FBlueprintInt32Column UniqueConnectionIdData(const FUniqueConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionString|Columns", meta=(DisplayName="UniqueOptionString Data")) + static FBlueprintInt32Column UniqueOptionStringData(const FUniqueOptionStringQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_connection_id") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_string") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="UniqueConnectionId Where")) - static FUniqueConnectionIdQuery UniqueConnectionIdWhere(FUniqueConnectionIdQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionString", meta=(DisplayName="UniqueOptionString Where")) + static FUniqueOptionStringQuery UniqueOptionStringWhere(FUniqueOptionStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22002,17 +26819,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="From UniqueI128")) - static FUniqueI128Query FromUniqueI128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU128", meta=(DisplayName="From UniqueOptionU128")) + static FUniqueOptionU128Query FromUniqueOptionU128() { - FUniqueI128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI128().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_128"); + FUniqueOptionU128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU128().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI128QueryToBlueprintQuery(const FUniqueI128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU128QueryToBlueprintQuery(const FUniqueOptionU128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22020,17 +26837,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128|Columns", meta=(DisplayName="UniqueI128 Data")) - static FBlueprintInt32Column UniqueI128Data(const FUniqueI128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU128|Columns", meta=(DisplayName="UniqueOptionU128 Data")) + static FBlueprintInt32Column UniqueOptionU128Data(const FUniqueOptionU128Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_128") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_128") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="UniqueI128 Where")) - static FUniqueI128Query UniqueI128Where(FUniqueI128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU128", meta=(DisplayName="UniqueOptionU128 Where")) + static FUniqueOptionU128Query UniqueOptionU128Where(FUniqueOptionU128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22040,17 +26857,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="From UniqueI16")) - static FUniqueI16Query FromUniqueI16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU16", meta=(DisplayName="From UniqueOptionU16")) + static FUniqueOptionU16Query FromUniqueOptionU16() { - FUniqueI16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI16().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_16"); + FUniqueOptionU16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU16().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI16QueryToBlueprintQuery(const FUniqueI16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU16QueryToBlueprintQuery(const FUniqueOptionU16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22058,17 +26875,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16|Columns", meta=(DisplayName="UniqueI16 Data")) - static FBlueprintInt32Column UniqueI16Data(const FUniqueI16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU16|Columns", meta=(DisplayName="UniqueOptionU16 Data")) + static FBlueprintInt32Column UniqueOptionU16Data(const FUniqueOptionU16Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_16") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_16") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="UniqueI16 Where")) - static FUniqueI16Query UniqueI16Where(FUniqueI16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU16", meta=(DisplayName="UniqueOptionU16 Where")) + static FUniqueOptionU16Query UniqueOptionU16Where(FUniqueOptionU16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22078,17 +26895,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="From UniqueI256")) - static FUniqueI256Query FromUniqueI256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU256", meta=(DisplayName="From UniqueOptionU256")) + static FUniqueOptionU256Query FromUniqueOptionU256() { - FUniqueI256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI256().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_256"); + FUniqueOptionU256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU256().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI256QueryToBlueprintQuery(const FUniqueI256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU256QueryToBlueprintQuery(const FUniqueOptionU256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22096,17 +26913,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256|Columns", meta=(DisplayName="UniqueI256 Data")) - static FBlueprintInt32Column UniqueI256Data(const FUniqueI256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU256|Columns", meta=(DisplayName="UniqueOptionU256 Data")) + static FBlueprintInt32Column UniqueOptionU256Data(const FUniqueOptionU256Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_256") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_256") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="UniqueI256 Where")) - static FUniqueI256Query UniqueI256Where(FUniqueI256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU256", meta=(DisplayName="UniqueOptionU256 Where")) + static FUniqueOptionU256Query UniqueOptionU256Where(FUniqueOptionU256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22116,17 +26933,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="From UniqueI32")) - static FUniqueI32Query FromUniqueI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU32", meta=(DisplayName="From UniqueOptionU32")) + static FUniqueOptionU32Query FromUniqueOptionU32() { - FUniqueI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_32"); + FUniqueOptionU32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU32().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI32QueryToBlueprintQuery(const FUniqueI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU32QueryToBlueprintQuery(const FUniqueOptionU32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22134,26 +26951,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32|Columns", meta=(DisplayName="UniqueI32 N")) - static FBlueprintInt32Column UniqueI32N(const FUniqueI32Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32|Columns", meta=(DisplayName="UniqueI32 Data")) - static FBlueprintInt32Column UniqueI32Data(const FUniqueI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU32|Columns", meta=(DisplayName="UniqueOptionU32 Data")) + static FBlueprintInt32Column UniqueOptionU32Data(const FUniqueOptionU32Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_32") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_32") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="UniqueI32 Where")) - static FUniqueI32Query UniqueI32Where(FUniqueI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU32", meta=(DisplayName="UniqueOptionU32 Where")) + static FUniqueOptionU32Query UniqueOptionU32Where(FUniqueOptionU32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22163,17 +26971,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="From UniqueI64")) - static FUniqueI64Query FromUniqueI64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU64", meta=(DisplayName="From UniqueOptionU64")) + static FUniqueOptionU64Query FromUniqueOptionU64() { - FUniqueI64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI64().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_64"); + FUniqueOptionU64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU64().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI64QueryToBlueprintQuery(const FUniqueI64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU64QueryToBlueprintQuery(const FUniqueOptionU64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22181,26 +26989,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64|Columns", meta=(DisplayName="UniqueI64 N")) - static FBlueprintInt64Column UniqueI64N(const FUniqueI64Query& Query) - { - FBlueprintInt64Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64|Columns", meta=(DisplayName="UniqueI64 Data")) - static FBlueprintInt32Column UniqueI64Data(const FUniqueI64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU64|Columns", meta=(DisplayName="UniqueOptionU64 Data")) + static FBlueprintInt32Column UniqueOptionU64Data(const FUniqueOptionU64Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_64") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_64") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="UniqueI64 Where")) - static FUniqueI64Query UniqueI64Where(FUniqueI64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU64", meta=(DisplayName="UniqueOptionU64 Where")) + static FUniqueOptionU64Query UniqueOptionU64Where(FUniqueOptionU64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22210,17 +27009,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="From UniqueI8")) - static FUniqueI8Query FromUniqueI8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU8", meta=(DisplayName="From UniqueOptionU8")) + static FUniqueOptionU8Query FromUniqueOptionU8() { - FUniqueI8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI8().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_8"); + FUniqueOptionU8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU8().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI8QueryToBlueprintQuery(const FUniqueI8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU8QueryToBlueprintQuery(const FUniqueOptionU8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22228,17 +27027,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8|Columns", meta=(DisplayName="UniqueI8 Data")) - static FBlueprintInt32Column UniqueI8Data(const FUniqueI8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU8|Columns", meta=(DisplayName="UniqueOptionU8 Data")) + static FBlueprintInt32Column UniqueOptionU8Data(const FUniqueOptionU8Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_8") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_8") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="UniqueI8 Where")) - static FUniqueI8Query UniqueI8Where(FUniqueI8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU8", meta=(DisplayName="UniqueOptionU8 Where")) + static FUniqueOptionU8Query UniqueOptionU8Where(FUniqueOptionU8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22248,17 +27047,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="From UniqueIdentity")) - static FUniqueIdentityQuery FromUniqueIdentity() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionUuid", meta=(DisplayName="From UniqueOptionUuid")) + static FUniqueOptionUuidQuery FromUniqueOptionUuid() { - FUniqueIdentityQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueIdentity().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_identity"); + FUniqueOptionUuidQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionUuid().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_uuid"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueIdentityQueryToBlueprintQuery(const FUniqueIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionUuid", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionUuidQueryToBlueprintQuery(const FUniqueOptionUuidQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22266,26 +27065,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity|Columns", meta=(DisplayName="UniqueIdentity I")) - static FBlueprintIdentityColumn UniqueIdentityI(const FUniqueIdentityQuery& Query) - { - FBlueprintIdentityColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_identity") : Query.ResultSourceName; - Column.ColumnName = TEXT("i"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity|Columns", meta=(DisplayName="UniqueIdentity Data")) - static FBlueprintInt32Column UniqueIdentityData(const FUniqueIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionUuid|Columns", meta=(DisplayName="UniqueOptionUuid Data")) + static FBlueprintInt32Column UniqueOptionUuidData(const FUniqueOptionUuidQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_identity") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_uuid") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="UniqueIdentity Where")) - static FUniqueIdentityQuery UniqueIdentityWhere(FUniqueIdentityQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionUuid", meta=(DisplayName="UniqueOptionUuid Where")) + static FUniqueOptionUuidQuery UniqueOptionUuidWhere(FUniqueOptionUuidQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -23957,6 +28747,40 @@ class TESTCLIENT_API USubscriptionBuilder : public USubscriptionBuilderBase USubscriptionBuilder* AddUniqueIdentityQuery(const FUniqueIdentityQuery& Query); + USubscriptionBuilder* AddUniqueOptionBoolQuery(const FUniqueOptionBoolQuery& Query); + + USubscriptionBuilder* AddUniqueOptionConnectionIdQuery(const FUniqueOptionConnectionIdQuery& Query); + + USubscriptionBuilder* AddUniqueOptionI128Query(const FUniqueOptionI128Query& Query); + + USubscriptionBuilder* AddUniqueOptionI16Query(const FUniqueOptionI16Query& Query); + + USubscriptionBuilder* AddUniqueOptionI256Query(const FUniqueOptionI256Query& Query); + + USubscriptionBuilder* AddUniqueOptionI32Query(const FUniqueOptionI32Query& Query); + + USubscriptionBuilder* AddUniqueOptionI64Query(const FUniqueOptionI64Query& Query); + + USubscriptionBuilder* AddUniqueOptionI8Query(const FUniqueOptionI8Query& Query); + + USubscriptionBuilder* AddUniqueOptionIdentityQuery(const FUniqueOptionIdentityQuery& Query); + + USubscriptionBuilder* AddUniqueOptionStringQuery(const FUniqueOptionStringQuery& Query); + + USubscriptionBuilder* AddUniqueOptionU128Query(const FUniqueOptionU128Query& Query); + + USubscriptionBuilder* AddUniqueOptionU16Query(const FUniqueOptionU16Query& Query); + + USubscriptionBuilder* AddUniqueOptionU256Query(const FUniqueOptionU256Query& Query); + + USubscriptionBuilder* AddUniqueOptionU32Query(const FUniqueOptionU32Query& Query); + + USubscriptionBuilder* AddUniqueOptionU64Query(const FUniqueOptionU64Query& Query); + + USubscriptionBuilder* AddUniqueOptionU8Query(const FUniqueOptionU8Query& Query); + + USubscriptionBuilder* AddUniqueOptionUuidQuery(const FUniqueOptionUuidQuery& Query); + USubscriptionBuilder* AddUniqueStringQuery(const FUniqueStringQuery& Query); USubscriptionBuilder* AddUniqueU128Query(const FUniqueU128Query& Query); diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionBoolTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionBoolTable.g.h new file mode 100644 index 00000000000..a380b8df12d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionBoolTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionBoolType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionBoolTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionBoolBUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> BIndexHelper; + +public: + UUniqueOptionBoolBUniqueIndex() + // Initialize the helper with the specific unique index name + : BIndexHelper("b") { + } + + /** + * Finds a UniqueOptionBool by their unique b. + * @param Key The b to search for. + * @return The found FUniqueOptionBoolType, or a default-constructed FUniqueOptionBoolType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionBoolIndex") + FUniqueOptionBoolType Find(FTestClientOptionalBool Key) + { + // Simply delegate the call to the internal helper + return BIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionBoolCache) + { + BIndexHelper.Cache = InUniqueOptionBoolCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionBoolTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionBoolBUniqueIndex* B; + + void PostInitialize(); + + /** Update function for unique_option_bool table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionBoolInsert, + const FEventContext&, Context, + const FUniqueOptionBoolType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionBoolUpdate, + const FEventContext&, Context, + const FUniqueOptionBoolType&, OldRow, + const FUniqueOptionBoolType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionBoolDelete, + const FEventContext&, Context, + const FUniqueOptionBoolType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionBoolInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionBoolUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionBoolDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_bool"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h new file mode 100644 index 00000000000..0815312c56b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionConnectionIdType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionConnectionIdTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionConnectionIdAUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> AIndexHelper; + +public: + UUniqueOptionConnectionIdAUniqueIndex() + // Initialize the helper with the specific unique index name + : AIndexHelper("a") { + } + + /** + * Finds a UniqueOptionConnectionId by their unique a. + * @param Key The a to search for. + * @return The found FUniqueOptionConnectionIdType, or a default-constructed FUniqueOptionConnectionIdType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionConnectionIdIndex") + FUniqueOptionConnectionIdType Find(FTestClientOptionalConnectionId Key) + { + // Simply delegate the call to the internal helper + return AIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionConnectionIdCache) + { + AIndexHelper.Cache = InUniqueOptionConnectionIdCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionConnectionIdTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionConnectionIdAUniqueIndex* A; + + void PostInitialize(); + + /** Update function for unique_option_connection_id table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionConnectionIdInsert, + const FEventContext&, Context, + const FUniqueOptionConnectionIdType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionConnectionIdUpdate, + const FEventContext&, Context, + const FUniqueOptionConnectionIdType&, OldRow, + const FUniqueOptionConnectionIdType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionConnectionIdDelete, + const FEventContext&, Context, + const FUniqueOptionConnectionIdType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionConnectionIdInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionConnectionIdUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionConnectionIdDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_connection_id"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI128Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI128Table.g.h new file mode 100644 index 00000000000..f0610ad66f5 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI128Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI128Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI128Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI128NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI128NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI128 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI128Type, or a default-constructed FUniqueOptionI128Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionI128Index") + FUniqueOptionI128Type Find(FTestClientOptionalInt128 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI128Cache) + { + NIndexHelper.Cache = InUniqueOptionI128Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI128Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI128NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_128 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI128Insert, + const FEventContext&, Context, + const FUniqueOptionI128Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI128Update, + const FEventContext&, Context, + const FUniqueOptionI128Type&, OldRow, + const FUniqueOptionI128Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI128Delete, + const FEventContext&, Context, + const FUniqueOptionI128Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI128Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI128Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI128Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_128"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI16Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI16Table.g.h new file mode 100644 index 00000000000..dafef01fb9c --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI16Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI16Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI16Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI16NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI16NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI16 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI16Type, or a default-constructed FUniqueOptionI16Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FUniqueOptionI16Type Find(FTestClientOptionalInt16 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI16Cache) + { + NIndexHelper.Cache = InUniqueOptionI16Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI16Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI16NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_16 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI16Insert, + const FEventContext&, Context, + const FUniqueOptionI16Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI16Update, + const FEventContext&, Context, + const FUniqueOptionI16Type&, OldRow, + const FUniqueOptionI16Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI16Delete, + const FEventContext&, Context, + const FUniqueOptionI16Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI16Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI16Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI16Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_16"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI256Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI256Table.g.h new file mode 100644 index 00000000000..90978f35ba3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI256Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI256Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI256Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI256NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI256NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI256 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI256Type, or a default-constructed FUniqueOptionI256Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionI256Index") + FUniqueOptionI256Type Find(FTestClientOptionalInt256 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI256Cache) + { + NIndexHelper.Cache = InUniqueOptionI256Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI256Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI256NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_256 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI256Insert, + const FEventContext&, Context, + const FUniqueOptionI256Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI256Update, + const FEventContext&, Context, + const FUniqueOptionI256Type&, OldRow, + const FUniqueOptionI256Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI256Delete, + const FEventContext&, Context, + const FUniqueOptionI256Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI256Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI256Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI256Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_256"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI32Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI32Table.g.h new file mode 100644 index 00000000000..aae5e1112e1 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI32Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI32Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI32Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI32NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI32NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI32 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI32Type, or a default-constructed FUniqueOptionI32Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionI32Index") + FUniqueOptionI32Type Find(FTestClientOptionalInt32 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI32Cache) + { + NIndexHelper.Cache = InUniqueOptionI32Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI32Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI32NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_32 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI32Insert, + const FEventContext&, Context, + const FUniqueOptionI32Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI32Update, + const FEventContext&, Context, + const FUniqueOptionI32Type&, OldRow, + const FUniqueOptionI32Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI32Delete, + const FEventContext&, Context, + const FUniqueOptionI32Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI32Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI32Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI32Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_32"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI64Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI64Table.g.h new file mode 100644 index 00000000000..e82a235e134 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI64Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI64Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI64Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI64NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI64NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI64 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI64Type, or a default-constructed FUniqueOptionI64Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionI64Index") + FUniqueOptionI64Type Find(FTestClientOptionalInt64 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI64Cache) + { + NIndexHelper.Cache = InUniqueOptionI64Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI64Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI64NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_64 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI64Insert, + const FEventContext&, Context, + const FUniqueOptionI64Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI64Update, + const FEventContext&, Context, + const FUniqueOptionI64Type&, OldRow, + const FUniqueOptionI64Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI64Delete, + const FEventContext&, Context, + const FUniqueOptionI64Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI64Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI64Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI64Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_64"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI8Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI8Table.g.h new file mode 100644 index 00000000000..894d5079c93 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI8Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI8Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI8Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI8NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI8NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI8 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI8Type, or a default-constructed FUniqueOptionI8Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FUniqueOptionI8Type Find(FTestClientOptionalInt8 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI8Cache) + { + NIndexHelper.Cache = InUniqueOptionI8Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI8Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI8NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_8 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI8Insert, + const FEventContext&, Context, + const FUniqueOptionI8Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI8Update, + const FEventContext&, Context, + const FUniqueOptionI8Type&, OldRow, + const FUniqueOptionI8Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI8Delete, + const FEventContext&, Context, + const FUniqueOptionI8Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI8Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI8Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI8Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_8"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionIdentityTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionIdentityTable.g.h new file mode 100644 index 00000000000..ec2f4860a51 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionIdentityTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionIdentityType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionIdentityTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionIdentityIUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> IIndexHelper; + +public: + UUniqueOptionIdentityIUniqueIndex() + // Initialize the helper with the specific unique index name + : IIndexHelper("i") { + } + + /** + * Finds a UniqueOptionIdentity by their unique i. + * @param Key The i to search for. + * @return The found FUniqueOptionIdentityType, or a default-constructed FUniqueOptionIdentityType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionIdentityIndex") + FUniqueOptionIdentityType Find(FTestClientOptionalIdentity Key) + { + // Simply delegate the call to the internal helper + return IIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionIdentityCache) + { + IIndexHelper.Cache = InUniqueOptionIdentityCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionIdentityTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionIdentityIUniqueIndex* I; + + void PostInitialize(); + + /** Update function for unique_option_identity table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionIdentityInsert, + const FEventContext&, Context, + const FUniqueOptionIdentityType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionIdentityUpdate, + const FEventContext&, Context, + const FUniqueOptionIdentityType&, OldRow, + const FUniqueOptionIdentityType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionIdentityDelete, + const FEventContext&, Context, + const FUniqueOptionIdentityType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionIdentityInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionIdentityUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionIdentityDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_identity"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionStringTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionStringTable.g.h new file mode 100644 index 00000000000..3c9e9d02081 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionStringTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionStringType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionStringTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionStringSUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> SIndexHelper; + +public: + UUniqueOptionStringSUniqueIndex() + // Initialize the helper with the specific unique index name + : SIndexHelper("s") { + } + + /** + * Finds a UniqueOptionString by their unique s. + * @param Key The s to search for. + * @return The found FUniqueOptionStringType, or a default-constructed FUniqueOptionStringType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionStringIndex") + FUniqueOptionStringType Find(FTestClientOptionalString Key) + { + // Simply delegate the call to the internal helper + return SIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionStringCache) + { + SIndexHelper.Cache = InUniqueOptionStringCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionStringTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionStringSUniqueIndex* S; + + void PostInitialize(); + + /** Update function for unique_option_string table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionStringInsert, + const FEventContext&, Context, + const FUniqueOptionStringType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionStringUpdate, + const FEventContext&, Context, + const FUniqueOptionStringType&, OldRow, + const FUniqueOptionStringType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionStringDelete, + const FEventContext&, Context, + const FUniqueOptionStringType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionStringInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionStringUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionStringDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_string"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU128Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU128Table.g.h new file mode 100644 index 00000000000..0e0d9144cc0 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU128Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU128Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU128Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU128NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU128NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU128 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU128Type, or a default-constructed FUniqueOptionU128Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionU128Index") + FUniqueOptionU128Type Find(FTestClientOptionalUInt128 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU128Cache) + { + NIndexHelper.Cache = InUniqueOptionU128Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU128Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU128NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_128 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU128Insert, + const FEventContext&, Context, + const FUniqueOptionU128Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU128Update, + const FEventContext&, Context, + const FUniqueOptionU128Type&, OldRow, + const FUniqueOptionU128Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU128Delete, + const FEventContext&, Context, + const FUniqueOptionU128Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU128Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU128Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU128Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_128"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU16Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU16Table.g.h new file mode 100644 index 00000000000..66b6bb96722 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU16Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU16Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU16Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU16NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU16NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU16 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU16Type, or a default-constructed FUniqueOptionU16Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FUniqueOptionU16Type Find(FTestClientOptionalUInt16 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU16Cache) + { + NIndexHelper.Cache = InUniqueOptionU16Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU16Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU16NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_16 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU16Insert, + const FEventContext&, Context, + const FUniqueOptionU16Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU16Update, + const FEventContext&, Context, + const FUniqueOptionU16Type&, OldRow, + const FUniqueOptionU16Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU16Delete, + const FEventContext&, Context, + const FUniqueOptionU16Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU16Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU16Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU16Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_16"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU256Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU256Table.g.h new file mode 100644 index 00000000000..f7e79d68064 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU256Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU256Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU256Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU256NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU256NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU256 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU256Type, or a default-constructed FUniqueOptionU256Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionU256Index") + FUniqueOptionU256Type Find(FTestClientOptionalUInt256 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU256Cache) + { + NIndexHelper.Cache = InUniqueOptionU256Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU256Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU256NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_256 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU256Insert, + const FEventContext&, Context, + const FUniqueOptionU256Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU256Update, + const FEventContext&, Context, + const FUniqueOptionU256Type&, OldRow, + const FUniqueOptionU256Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU256Delete, + const FEventContext&, Context, + const FUniqueOptionU256Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU256Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU256Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU256Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_256"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU32Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU32Table.g.h new file mode 100644 index 00000000000..b96a68b4ddf --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU32Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU32Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU32Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU32NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU32NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU32 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU32Type, or a default-constructed FUniqueOptionU32Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FUniqueOptionU32Type Find(FTestClientOptionalUInt32 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU32Cache) + { + NIndexHelper.Cache = InUniqueOptionU32Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU32Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU32NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_32 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU32Insert, + const FEventContext&, Context, + const FUniqueOptionU32Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU32Update, + const FEventContext&, Context, + const FUniqueOptionU32Type&, OldRow, + const FUniqueOptionU32Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU32Delete, + const FEventContext&, Context, + const FUniqueOptionU32Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU32Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU32Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU32Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_32"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU64Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU64Table.g.h new file mode 100644 index 00000000000..2411c430785 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU64Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU64Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU64Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU64NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU64NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU64 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU64Type, or a default-constructed FUniqueOptionU64Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FUniqueOptionU64Type Find(FTestClientOptionalUInt64 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU64Cache) + { + NIndexHelper.Cache = InUniqueOptionU64Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU64Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU64NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_64 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU64Insert, + const FEventContext&, Context, + const FUniqueOptionU64Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU64Update, + const FEventContext&, Context, + const FUniqueOptionU64Type&, OldRow, + const FUniqueOptionU64Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU64Delete, + const FEventContext&, Context, + const FUniqueOptionU64Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU64Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU64Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU64Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_64"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU8Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU8Table.g.h new file mode 100644 index 00000000000..e2764539b3c --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU8Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU8Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU8Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU8NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU8NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU8 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU8Type, or a default-constructed FUniqueOptionU8Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionU8Index") + FUniqueOptionU8Type Find(FTestClientOptionalUInt8 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU8Cache) + { + NIndexHelper.Cache = InUniqueOptionU8Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU8Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU8NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_8 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU8Insert, + const FEventContext&, Context, + const FUniqueOptionU8Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU8Update, + const FEventContext&, Context, + const FUniqueOptionU8Type&, OldRow, + const FUniqueOptionU8Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU8Delete, + const FEventContext&, Context, + const FUniqueOptionU8Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU8Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU8Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU8Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_8"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionUuidTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionUuidTable.g.h new file mode 100644 index 00000000000..2d91366e0bf --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionUuidTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionUuidType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionUuidTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionUuidUUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> UIndexHelper; + +public: + UUniqueOptionUuidUUniqueIndex() + // Initialize the helper with the specific unique index name + : UIndexHelper("u") { + } + + /** + * Finds a UniqueOptionUuid by their unique u. + * @param Key The u to search for. + * @return The found FUniqueOptionUuidType, or a default-constructed FUniqueOptionUuidType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionUuidIndex") + FUniqueOptionUuidType Find(FTestClientOptionalUuid Key) + { + // Simply delegate the call to the internal helper + return UIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionUuidCache) + { + UIndexHelper.Cache = InUniqueOptionUuidCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionUuidTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionUuidUUniqueIndex* U; + + void PostInitialize(); + + /** Update function for unique_option_uuid table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionUuidInsert, + const FEventContext&, Context, + const FUniqueOptionUuidType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionUuidUpdate, + const FEventContext&, Context, + const FUniqueOptionUuidType&, OldRow, + const FUniqueOptionUuidType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionUuidDelete, + const FEventContext&, Context, + const FUniqueOptionUuidType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionUuidInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionUuidUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionUuidDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_uuid"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h index fa9b863fd39..9d4c678a794 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h @@ -4,9 +4,9 @@ #pragma once #include "CoreMinimal.h" #include "BSATN/UESpacetimeDB.h" -#include "Kismet/BlueprintFunctionLibrary.h" -#include "Types/Builtins.h" #include "ModuleBindings/Types/SimpleEnumType.g.h" +#include "Types/Builtins.h" +#include "Kismet/BlueprintFunctionLibrary.h" #include "EnumWithPayloadType.g.generated.h" UENUM(BlueprintType) @@ -46,7 +46,7 @@ struct TESTCLIENT_API FEnumWithPayloadType public: FEnumWithPayloadType() = default; - TVariant, FSpacetimeDBInt128, FSpacetimeDBConnectionId, uint8, TArray, FSpacetimeDBInt256, TArray, TArray, FSpacetimeDBUuid, int8, FSpacetimeDBUInt256, float, int64, uint32, int16, int32, FSpacetimeDBUInt128> MessageData; + TVariant, FSpacetimeDBUInt128, FSpacetimeDBTimestamp, FSpacetimeDBConnectionId, uint16, int64, TArray, FSpacetimeDBUInt256, int32, FSpacetimeDBInt256, int16, bool, FString, uint8, uint64, FSpacetimeDBInt128, float, TArray, TArray, int8, double, FSpacetimeDBUuid> MessageData; UPROPERTY(BlueprintReadOnly) EEnumWithPayloadTag Tag = static_cast(0); diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionBoolType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionBoolType.g.h new file mode 100644 index 00000000000..cbf6056b8a0 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionBoolType.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "UniqueOptionBoolType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionBoolType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalBool B; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionBoolType& Other) const + { + return B == Other.B && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionBoolType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionBoolType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionBoolType The FUniqueOptionBoolType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionBoolType& UniqueOptionBoolType) +{ + uint32 Hash = GetTypeHash(UniqueOptionBoolType.B); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionBoolType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionBoolType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionBoolType, B, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionConnectionIdType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionConnectionIdType.g.h new file mode 100644 index 00000000000..be71b22c997 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionConnectionIdType.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionConnectionIdType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionConnectionIdType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalConnectionId A; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionConnectionIdType& Other) const + { + return A == Other.A && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionConnectionIdType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionConnectionIdType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionConnectionIdType The FUniqueOptionConnectionIdType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionConnectionIdType& UniqueOptionConnectionIdType) +{ + uint32 Hash = GetTypeHash(UniqueOptionConnectionIdType.A); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionConnectionIdType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionConnectionIdType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionConnectionIdType, A, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI128Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI128Type.g.h new file mode 100644 index 00000000000..64de78df168 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI128Type.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionI128Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI128Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalInt128 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI128Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI128Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI128Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI128Type The FUniqueOptionI128Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI128Type& UniqueOptionI128Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI128Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI128Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI128Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI128Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI16Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI16Type.g.h new file mode 100644 index 00000000000..eb3807359b2 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI16Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "UniqueOptionI16Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI16Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI16Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI16Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI16Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI16Type The FUniqueOptionI16Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI16Type& UniqueOptionI16Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI16Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI16Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI16Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI16Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI256Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI256Type.g.h new file mode 100644 index 00000000000..081c7e15792 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI256Type.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionI256Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI256Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalInt256 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI256Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI256Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI256Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI256Type The FUniqueOptionI256Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI256Type& UniqueOptionI256Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI256Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI256Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI256Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI256Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI32Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI32Type.g.h new file mode 100644 index 00000000000..2d82803202f --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI32Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "UniqueOptionI32Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI32Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalInt32 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI32Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI32Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI32Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI32Type The FUniqueOptionI32Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI32Type& UniqueOptionI32Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI32Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI32Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI32Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI32Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI64Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI64Type.g.h new file mode 100644 index 00000000000..087eeeffa33 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI64Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "UniqueOptionI64Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI64Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalInt64 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI64Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI64Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI64Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI64Type The FUniqueOptionI64Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI64Type& UniqueOptionI64Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI64Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI64Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI64Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI64Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI8Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI8Type.g.h new file mode 100644 index 00000000000..2d2944586b3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI8Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "UniqueOptionI8Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI8Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI8Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI8Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI8Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI8Type The FUniqueOptionI8Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI8Type& UniqueOptionI8Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI8Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI8Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI8Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI8Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionIdentityType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionIdentityType.g.h new file mode 100644 index 00000000000..f8729f9d14b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionIdentityType.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionIdentityType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionIdentityType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalIdentity I; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionIdentityType& Other) const + { + return I == Other.I && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionIdentityType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionIdentityType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionIdentityType The FUniqueOptionIdentityType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionIdentityType& UniqueOptionIdentityType) +{ + uint32 Hash = GetTypeHash(UniqueOptionIdentityType.I); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionIdentityType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionIdentityType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionIdentityType, I, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionStringType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionStringType.g.h new file mode 100644 index 00000000000..6a7bfb460b3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionStringType.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "UniqueOptionStringType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionStringType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalString S; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionStringType& Other) const + { + return S == Other.S && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionStringType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionStringType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionStringType The FUniqueOptionStringType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionStringType& UniqueOptionStringType) +{ + uint32 Hash = GetTypeHash(UniqueOptionStringType.S); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionStringType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionStringType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionStringType, S, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU128Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU128Type.g.h new file mode 100644 index 00000000000..05c744c5190 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU128Type.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionU128Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU128Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalUInt128 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU128Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU128Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU128Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU128Type The FUniqueOptionU128Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU128Type& UniqueOptionU128Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU128Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU128Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU128Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU128Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU16Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU16Type.g.h new file mode 100644 index 00000000000..de5258389d9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU16Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "UniqueOptionU16Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU16Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU16Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU16Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU16Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU16Type The FUniqueOptionU16Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU16Type& UniqueOptionU16Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU16Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU16Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU16Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU16Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU256Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU256Type.g.h new file mode 100644 index 00000000000..15eb3c283f8 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU256Type.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionU256Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU256Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalUInt256 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU256Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU256Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU256Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU256Type The FUniqueOptionU256Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU256Type& UniqueOptionU256Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU256Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU256Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU256Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU256Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU32Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU32Type.g.h new file mode 100644 index 00000000000..beabfc2fee0 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU32Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "UniqueOptionU32Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU32Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU32Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU32Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU32Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU32Type The FUniqueOptionU32Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU32Type& UniqueOptionU32Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU32Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU32Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU32Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU32Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU64Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU64Type.g.h new file mode 100644 index 00000000000..644f32aff36 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU64Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "UniqueOptionU64Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU64Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU64Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU64Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU64Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU64Type The FUniqueOptionU64Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU64Type& UniqueOptionU64Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU64Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU64Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU64Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU64Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU8Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU8Type.g.h new file mode 100644 index 00000000000..5c44d81577f --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU8Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "UniqueOptionU8Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU8Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalUInt8 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU8Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU8Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU8Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU8Type The FUniqueOptionU8Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU8Type& UniqueOptionU8Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU8Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU8Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU8Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU8Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionUuidType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionUuidType.g.h new file mode 100644 index 00000000000..ec080efd0cc --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionUuidType.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionUuidType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionUuidType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalUuid U; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionUuidType& Other) const + { + return U == Other.U && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionUuidType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionUuidType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionUuidType The FUniqueOptionUuidType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionUuidType& UniqueOptionUuidType) +{ + uint32 Hash = GetTypeHash(UniqueOptionUuidType.U); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionUuidType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionUuidType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionUuidType, U, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/PrimitiveHandlerList.def b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/PrimitiveHandlerList.def index 56a099a0a11..5ea3e7b5f59 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/PrimitiveHandlerList.def +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/PrimitiveHandlerList.def @@ -40,6 +40,26 @@ M(Bool , B, false, 0xbeef, FUniqueBoolType) \ M(String, S, TEXT(""), 0xbeef, FUniqueStringType) +/* + * Macro list for unique option tables used in tests that insert then delete rows. + * Arguments: (Suffix, KeyField, SomeKeyLiteral, NoneKeyLiteral, ExpectedValue, RowStructType) + */ +#define FOREACH_UNIQUE_OPTION_PRIMITIVE(M) \ + M(U8 , N, FTestClientOptionalUInt8(0), FTestClientOptionalUInt8(), 0xbeef, FUniqueOptionU8Type) \ + M(U16 , N, FTestClientOptionalUInt16(0), FTestClientOptionalUInt16(), 0xbeef, FUniqueOptionU16Type) \ + M(U32 , N, FTestClientOptionalUInt32(0), FTestClientOptionalUInt32(), 0xbeef, FUniqueOptionU32Type) \ + M(U64 , N, FTestClientOptionalUInt64(0), FTestClientOptionalUInt64(), 0xbeef, FUniqueOptionU64Type) \ + M(U128 , N, FTestClientOptionalUInt128(FSpacetimeDBUInt128(0,0)), FTestClientOptionalUInt128(), 0xbeef, FUniqueOptionU128Type) \ + M(U256 , N, FTestClientOptionalUInt256(FSpacetimeDBUInt256(FSpacetimeDBUInt128(0,0),FSpacetimeDBUInt128(0,0))), FTestClientOptionalUInt256(), 0xbeef, FUniqueOptionU256Type) \ + M(I8 , N, FTestClientOptionalInt8(0), FTestClientOptionalInt8(), 0xbeef, FUniqueOptionI8Type) \ + M(I16 , N, FTestClientOptionalInt16(0), FTestClientOptionalInt16(), 0xbeef, FUniqueOptionI16Type) \ + M(I32 , N, FTestClientOptionalInt32(0), FTestClientOptionalInt32(), 0xbeef, FUniqueOptionI32Type) \ + M(I64 , N, FTestClientOptionalInt64(0), FTestClientOptionalInt64(), 0xbeef, FUniqueOptionI64Type) \ + M(I128 , N, FTestClientOptionalInt128(FSpacetimeDBInt128(0,0)), FTestClientOptionalInt128(), 0xbeef, FUniqueOptionI128Type) \ + M(I256 , N, FTestClientOptionalInt256(FSpacetimeDBInt256(FSpacetimeDBUInt128(0,0),FSpacetimeDBUInt128(0,0))), FTestClientOptionalInt256(), 0xbeef, FUniqueOptionI256Type) \ + M(Bool , B, FTestClientOptionalBool(false), FTestClientOptionalBool(), 0xbeef, FUniqueOptionBoolType) \ + M(String, S, FTestClientOptionalString(TEXT("")), FTestClientOptionalString(), 0xbeef, FUniqueOptionStringType) + /* * Macro list for primary-key tables used in update tests. * Arguments: (Suffix, KeyField, KeyLiteral, ExpectedValue, UpdatedValue, RowStructType) @@ -58,4 +78,4 @@ M(I128 , N, FSpacetimeDBInt128(0,0), 0xbeef, 0xbabe, FPkI128Type) \ M(I256 , N, FSpacetimeDBInt256(FSpacetimeDBUInt128(0,0),FSpacetimeDBUInt128(0,0)), 0xbeef, 0xbabe, FPkI256Type) \ M(Bool , B, false, 0xbeef, 0xbabe, FPkBoolType) \ - M(String, S, TEXT(""), 0xbeef, 0xbabe, FPkStringType) \ No newline at end of file + M(String, S, TEXT(""), 0xbeef, 0xbabe, FPkStringType) diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/SpacetimeFullClientTests.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/SpacetimeFullClientTests.h index 267e28840b0..9cf7f9042a7 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/SpacetimeFullClientTests.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/SpacetimeFullClientTests.h @@ -65,6 +65,10 @@ IMPLEMENT_SIMPLE_AUTOMATION_TEST(FInsertVecTest, "SpacetimeDB.TestClient.InsertV IMPLEMENT_SIMPLE_AUTOMATION_TEST(FInsertOptionSomeTest, "SpacetimeDB.TestClient.InsertOptionSomeTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) /** Tests inserting none optional types. */ IMPLEMENT_SIMPLE_AUTOMATION_TEST(FInsertOptionNoneTest, "SpacetimeDB.TestClient.InsertOptionNoneTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) +/** Tests deleting unique option rows with Some values. */ +IMPLEMENT_SIMPLE_AUTOMATION_TEST(FDeleteOptionSomeTest, "SpacetimeDB.TestClient.DeleteOptionSomeTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) +/** Tests deleting unique option rows with None values. */ +IMPLEMENT_SIMPLE_AUTOMATION_TEST(FDeleteOptionNoneTest, "SpacetimeDB.TestClient.DeleteOptionNoneTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) /** Tests inserting Result Ok types. */ IMPLEMENT_SIMPLE_AUTOMATION_TEST(FInsertResultOkTest, "SpacetimeDB.TestClient.InsertResultOkTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h index 45b80ed7dac..fa8989e4ffa 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h @@ -105,6 +105,44 @@ class UDeletePrimitiveHandler : public UTestHandler UFUNCTION() void OnDeleteUniqueString(const FEventContext& Context, const FUniqueStringType& Value); }; +/** Handler used for delete-option tests. */ +UCLASS() +class UDeleteOptionHandler : public UTestHandler +{ + GENERATED_BODY() +public: + bool bUseSome = false; + + UFUNCTION() void OnInsertUniqueOptionU8(const FEventContext& Context, const FUniqueOptionU8Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU8(const FEventContext& Context, const FUniqueOptionU8Type& Value); + UFUNCTION() void OnInsertUniqueOptionU16(const FEventContext& Context, const FUniqueOptionU16Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU16(const FEventContext& Context, const FUniqueOptionU16Type& Value); + UFUNCTION() void OnInsertUniqueOptionU32(const FEventContext& Context, const FUniqueOptionU32Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU32(const FEventContext& Context, const FUniqueOptionU32Type& Value); + UFUNCTION() void OnInsertUniqueOptionU64(const FEventContext& Context, const FUniqueOptionU64Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU64(const FEventContext& Context, const FUniqueOptionU64Type& Value); + UFUNCTION() void OnInsertUniqueOptionU128(const FEventContext& Context, const FUniqueOptionU128Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU128(const FEventContext& Context, const FUniqueOptionU128Type& Value); + UFUNCTION() void OnInsertUniqueOptionU256(const FEventContext& Context, const FUniqueOptionU256Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU256(const FEventContext& Context, const FUniqueOptionU256Type& Value); + UFUNCTION() void OnInsertUniqueOptionI8(const FEventContext& Context, const FUniqueOptionI8Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI8(const FEventContext& Context, const FUniqueOptionI8Type& Value); + UFUNCTION() void OnInsertUniqueOptionI16(const FEventContext& Context, const FUniqueOptionI16Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI16(const FEventContext& Context, const FUniqueOptionI16Type& Value); + UFUNCTION() void OnInsertUniqueOptionI32(const FEventContext& Context, const FUniqueOptionI32Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI32(const FEventContext& Context, const FUniqueOptionI32Type& Value); + UFUNCTION() void OnInsertUniqueOptionI64(const FEventContext& Context, const FUniqueOptionI64Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI64(const FEventContext& Context, const FUniqueOptionI64Type& Value); + UFUNCTION() void OnInsertUniqueOptionI128(const FEventContext& Context, const FUniqueOptionI128Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI128(const FEventContext& Context, const FUniqueOptionI128Type& Value); + UFUNCTION() void OnInsertUniqueOptionI256(const FEventContext& Context, const FUniqueOptionI256Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI256(const FEventContext& Context, const FUniqueOptionI256Type& Value); + UFUNCTION() void OnInsertUniqueOptionBool(const FEventContext& Context, const FUniqueOptionBoolType& Value); + UFUNCTION() void OnDeleteUniqueOptionBool(const FEventContext& Context, const FUniqueOptionBoolType& Value); + UFUNCTION() void OnInsertUniqueOptionString(const FEventContext& Context, const FUniqueOptionStringType& Value); + UFUNCTION() void OnDeleteUniqueOptionString(const FEventContext& Context, const FUniqueOptionStringType& Value); +}; + /** Handler used for update-primitive tests. */ UCLASS() class UUpdatePrimitiveHandler : public UTestHandler diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h index 331e301a2da..6fd15c89318 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h @@ -68,6 +68,23 @@ #include "ModuleBindings/Tables/UniqueI64Table.g.h" #include "ModuleBindings/Tables/UniqueI8Table.g.h" #include "ModuleBindings/Tables/UniqueIdentityTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionBoolTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionI128Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI16Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI256Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI32Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI64Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI8Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionIdentityTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionStringTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionU128Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU16Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU256Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU32Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU64Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU8Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionUuidTable.g.h" #include "ModuleBindings/Tables/UniqueStringTable.g.h" #include "ModuleBindings/Tables/UniqueU128Table.g.h" #include "ModuleBindings/Tables/UniqueU16Table.g.h" @@ -100,4 +117,4 @@ #include "ModuleBindings/Tables/VecU32Table.g.h" #include "ModuleBindings/Tables/VecU64Table.g.h" #include "ModuleBindings/Tables/VecU8Table.g.h" -#include "ModuleBindings/Tables/VecUnitStructTable.g.h" \ No newline at end of file +#include "ModuleBindings/Tables/VecUnitStructTable.g.h" diff --git a/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/SpacetimeDBClient.g.h b/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/SpacetimeDBClient.g.h index 3261075ff69..9f748d0d9c8 100644 --- a/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/SpacetimeDBClient.g.h +++ b/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/SpacetimeDBClient.g.h @@ -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.7.0 (commit 7b2d64cdf2e66aacac74ca7aaa0b4417100d380b). +// This was generated using spacetimedb cli version 2.7.0 (commit e64e7c0c15729126f00f2742ad3535cfa24da529). #pragma once #include "CoreMinimal.h" diff --git a/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/Types/ReturnEnumType.g.h b/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/Types/ReturnEnumType.g.h index a0235284c48..14b4b797c33 100644 --- a/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/Types/ReturnEnumType.g.h +++ b/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/Types/ReturnEnumType.g.h @@ -22,7 +22,7 @@ struct TESTPROCCLIENT_API FReturnEnumType public: FReturnEnumType() = default; - TVariant MessageData; + TVariant MessageData; UPROPERTY(BlueprintReadOnly) EReturnEnumTag Tag = static_cast(0); diff --git a/sdks/unreal/tests/TestViewClient/Source/TestViewClient/Public/ModuleBindings/SpacetimeDBClient.g.h b/sdks/unreal/tests/TestViewClient/Source/TestViewClient/Public/ModuleBindings/SpacetimeDBClient.g.h index f60aea86c1e..368932b6e26 100644 --- a/sdks/unreal/tests/TestViewClient/Source/TestViewClient/Public/ModuleBindings/SpacetimeDBClient.g.h +++ b/sdks/unreal/tests/TestViewClient/Source/TestViewClient/Public/ModuleBindings/SpacetimeDBClient.g.h @@ -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.7.0 (commit 7b2d64cdf2e66aacac74ca7aaa0b4417100d380b). +// This was generated using spacetimedb cli version 2.7.0 (commit e64e7c0c15729126f00f2742ad3535cfa24da529). #pragma once #include "CoreMinimal.h" diff --git a/sdks/unreal/tests/TestViewPkClient/Source/TestViewPkClient/Public/ModuleBindings/SpacetimeDBClient.g.h b/sdks/unreal/tests/TestViewPkClient/Source/TestViewPkClient/Public/ModuleBindings/SpacetimeDBClient.g.h index 76b4d6ff49c..e8cafd92658 100644 --- a/sdks/unreal/tests/TestViewPkClient/Source/TestViewPkClient/Public/ModuleBindings/SpacetimeDBClient.g.h +++ b/sdks/unreal/tests/TestViewPkClient/Source/TestViewPkClient/Public/ModuleBindings/SpacetimeDBClient.g.h @@ -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.7.0 (commit 7b2d64cdf2e66aacac74ca7aaa0b4417100d380b). +// This was generated using spacetimedb cli version 2.7.0 (commit e64e7c0c15729126f00f2742ad3535cfa24da529). #pragma once #include "CoreMinimal.h" diff --git a/sdks/unreal/tests/test.rs b/sdks/unreal/tests/test.rs index a5bb363db34..f3aa9eae311 100644 --- a/sdks/unreal/tests/test.rs +++ b/sdks/unreal/tests/test.rs @@ -179,6 +179,18 @@ fn unreal_insert_option_none() { make_test("InsertOptionNoneTest").run(); } +#[test] +#[serial(Group3)] +fn unreal_delete_option_some() { + make_test("DeleteOptionSomeTest").run(); +} + +#[test] +#[serial(Group3)] +fn unreal_delete_option_none() { + make_test("DeleteOptionNoneTest").run(); +} + #[test] #[serial(Group3)] fn unreal_insert_struct() {