Addresses #2969 (#2980)

# Description of Changes

The `ScheduleAt` type appears to have an outdated structure. I've
updated the structure of the `ScheduleAt` type represented in TypeScript
to be in line with the Rust type:
https://docs.rs/spacetimedb/latest/spacetimedb/enum.ScheduleAt.html

Namely, we were missing the inner Spacetime library types of
`TimeDuration` and `Timestamp`.

This is to address #2969.

# API and ABI breaking changes

This is an API breaking change in that it changes the API, but it's
breaking in that it fixes a bug.

# Expected complexity level and risk

2

# Testing

I have not done additional testing, but I thought I would get this PR
started to make it easier for the next person who comes along.

The ideal automated test to add would be one which connects a TypeScript
client to a SpacetimeDB module with a scheduled table, and verifies that
the type is correctly deserialized and represented in TypeScript when
the rows are sent down.

---------

Co-authored-by: Jeffrey Dallatezza <[email protected]>

Author: cloutiertyler

sdks/typescript/packages/sdk/src/schedule_at.ts

@@ -4,37 +4,47 @@ import type { AlgebraicValue } from './algebraic_value';
 export namespace ScheduleAt {
   export function getAlgebraicType(): AlgebraicType {
     return AlgebraicType.createSumType([
-      new SumTypeVariant('Interval', AlgebraicType.createU64Type()),
-      new SumTypeVariant('Time', AlgebraicType.createU64Type()),
+      new SumTypeVariant('Interval', AlgebraicType.createTimeDurationType()),
+      new SumTypeVariant('Time', AlgebraicType.createTimestampType()),
     ]);
   }
 
-  export function serialize(value: ScheduleAt): object {
-    switch (value.tag) {
-      case 'Interval':
-        return { Interval: value.value };
-      case 'Time':
-        return { Time: value.value };
-      default:
-        throw 'unreachable';
-    }
-  }
-
-  export type Interval = { tag: 'Interval'; value: BigInt };
+  export type Interval = {
+    tag: 'Interval';
+    value: { __time_duration_micros__: BigInt };
+  };
   export const Interval = (value: BigInt): Interval => ({
     tag: 'Interval',
-    value,
+    value: { __time_duration_micros__: value },
+  });
+  export type Time = {
+    tag: 'Time';
+    value: { __timestamp_micros_since_unix_epoch__: BigInt };
+  };
+  export const Time = (value: BigInt): Time => ({
+    tag: 'Time',
+    value: { __timestamp_micros_since_unix_epoch__: value },
   });
-  export type Time = { tag: 'Time'; value: BigInt };
-  export const Time = (value: BigInt): Time => ({ tag: 'Time', value });
 
   export function fromValue(value: AlgebraicValue): ScheduleAt {
     let sumValue = value.asSumValue();
     switch (sumValue.tag) {
       case 0:
-        return { tag: 'Interval', value: sumValue.value.asBigInt() };
+        return {
+          tag: 'Interval',
+          value: {
+            __time_duration_micros__: sumValue.value
+              .asProductValue()
+              .elements[0].asBigInt(),
+          },
+        };
       case 1:
-        return { tag: 'Time', value: sumValue.value.asBigInt() };
+        return {
+          tag: 'Time',
+          value: {
+            __timestamp_micros_since_unix_epoch__: sumValue.value.asBigInt(),
+          },
+        };
       default:
         throw 'unreachable';
     }