@synnaxlabs/x 0.12.0 → 0.14.1

package/.turbo/turbo-build.log

@@ -1,17 +1,17 @@
 
-> @synnaxlabs/x@0.12.0 build /home/runner/work/synnax/synnax/x/ts
+> @synnaxlabs/x@0.14.1 build /home/runner/work/synnax/synnax/x/ts
 > tsc --noEmit && vite build
 
 vite v5.1.2 building for production...
 transforming...
 [plugin:vite:resolve] Module "crypto" has been externalized for browser compatibility, imported by "/home/runner/work/synnax/synnax/node_modules/.pnpm/nanoid@3.0.0/node_modules/nanoid/index.js". See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.
-✓ 116 modules transformed.
+✓ 127 modules transformed.
 rendering chunks...
 
 [vite:dts] Start generate declaration files...
 computing gzip size...
-dist/x.es.js  289.91 kB │ gzip: 54.74 kB │ map: 595.98 kB
-[vite:dts] Declaration files built in 2784ms.
+dist/x.js  209.89 kB │ gzip: 49.04 kB │ map: 632.82 kB
+[vite:dts] Declaration files built in 3265ms.
 
-dist/x.cjs.js  290.78 kB │ gzip: 54.89 kB │ map: 596.09 kB
-✓ built in 3.63s
+dist/x.cjs  137.61 kB │ gzip: 39.21 kB │ map: 612.53 kB
+✓ built in 4.16s

package/dist/binary/encoder.d.ts

@@ -1,19 +1,4 @@
 import { type ZodSchema, type z } from "zod";
-/**
- * CustomTypeEncoder is an interface for a class that needs to transform its
- * value before encoding.
- */
-interface CustomTypeEncoder {
-    /** The Class the custom encoder is set for */
-    Class: Function;
-    /**
-     * The function that transforms the value before encoding;
-     *
-     * @param instance - The instance of the class to transform.
-     * @returns The transformed value.
-     */
-    write: <P>(instance: P) => unknown;
-}
 /**
  * EncoderDecoder is an entity that encodes and decodes messages to and from a
  * binary format.
@@ -36,24 +21,19 @@ export interface EncoderDecoder {
      */
     decode: <P>(data: Uint8Array | ArrayBuffer, schema?: ZodSchema<P>) => P;
 }
-interface StaticEncoderDecoder {
-    registerCustomType: (encoder: CustomTypeEncoder) => void;
-}
 /** MsgpackEncoderDecoder is a msgpack implementation of EncoderDecoder. */
 export declare class MsgpackEncoderDecoder implements EncoderDecoder {
     contentType: string;
     encode(payload: unknown): ArrayBuffer;
     decode<P extends z.ZodTypeAny>(data: Uint8Array | ArrayBuffer, schema?: P): z.output<P>;
-    static registerCustomType(encoder: CustomTypeEncoder): void;
 }
 /** JSONEncoderDecoder is a JSON implementation of EncoderDecoder. */
 export declare class JSONEncoderDecoder implements EncoderDecoder {
     contentType: string;
+    readonly decoder: TextDecoder;
+    constructor();
     encode(payload: unknown): ArrayBuffer;
     decode<P extends z.ZodTypeAny>(data: Uint8Array | ArrayBuffer, schema?: P): z.output<P>;
     static registerCustomType(): void;
 }
 export declare const ENCODERS: EncoderDecoder[];
-export declare const ENCODER_CLASSES: StaticEncoderDecoder[];
-export declare const registerCustomTypeEncoder: (encoder: CustomTypeEncoder) => void;
-export {};

package/dist/deep/difference.d.ts

@@ -0,0 +1,3 @@
+type PathValueTuple = [any, any];
+export declare const difference: (obj1: Record<string, any>, obj2: Record<string, any>, path?: string) => Record<string, PathValueTuple>;
+export {};

package/dist/deep/external.d.ts

@@ -5,3 +5,4 @@ export * from './merge';
 export * from './partial';
 export * from './equal';
 export * from './memo';
+export * from './difference';

package/dist/index.d.ts

@@ -24,3 +24,4 @@ export * from './binary';
 export * from './observe';
 export * from './change';
 export * from './shallowCopy';
+export * from './invert';

package/dist/invert.d.ts

@@ -0,0 +1 @@
+export declare const invert: (condition: boolean) => -1 | 1;

package/dist/optional.d.ts

@@ -1 +1,4 @@
 export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export type Required<T> = {
+    [P in keyof T]-?: T[P];
+};

package/dist/spatial/{bounds.d.ts → bounds/bounds.d.ts}

@@ -1,4 +1,4 @@
-import { type Bounds, bounds, type CrudeBounds } from './base';
+import { type Bounds, bounds, type CrudeBounds } from '../base';
 export { type Bounds, bounds };
 export type Crude = CrudeBounds;
 export declare const construct: (lower: number | Crude, upper?: number) => Bounds;

package/dist/spatial/bounds/index.d.ts

@@ -0,0 +1 @@
+export * as bounds from './bounds';

package/dist/spatial/{box.d.ts → box/box.d.ts}

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import type * as bounds from './bounds';
-import type * as dimensions from './dimensions';
-import * as direction from './direction';
-import * as location from './location';
-import * as xy from './xy';
+import type * as bounds from '../bounds/bounds';
+import type * as dimensions from '../dimensions/dimensions';
+import * as direction from '../direction/direction';
+import * as location from '../location/location';
+import * as xy from '../xy/xy';
 declare const cssBox: z.ZodObject<{
     top: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
     left: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
@@ -97,7 +97,7 @@ export declare const box: z.ZodObject<{
 export type Box = z.infer<typeof box>;
 export type CSS = z.infer<typeof cssBox>;
 export type DOMRect = z.infer<typeof domRect>;
-type Crude = DOMRect | Box | {
+export type Crude = DOMRect | Box | {
     getBoundingClientRect: () => DOMRect;
 };
 /** A box centered at (0,0) with a width and height of 0. */
@@ -147,7 +147,20 @@ export declare const copy: (b: Box, root?: location.CornerXY) => Box;
 export declare const construct: (first: number | DOMRect | xy.XY | Box | {
     getBoundingClientRect: () => DOMRect;
 }, second?: number | xy.XY | dimensions.Dimensions | dimensions.Signed, width?: number, height?: number, coordinateRoot?: location.CornerXY) => Box;
-export declare const resize: (b: Box, dims: dimensions.Dimensions) => Box;
+export interface Resize {
+    /**
+     * Sets the dimensions of the box to the given dimensions.
+     * @example resize(b, { width: 10, height: 10 }) // Sets the box to a 10x10 box.
+     */
+    (b: Crude, dims: dimensions.Dimensions | dimensions.Signed): Box;
+    /**
+     * Sets the dimension along the given direction to the given amount.
+     * @example resize(b, "x", 10) // Sets the width of the box to 10.
+     * @example resize(b, "y", 10) // Sets the height of the box to 10.
+    */
+    (b: Crude, direction: direction.Direction, amount: number): Box;
+}
+export declare const resize: Resize;
 /**
  * Checks if a box contains a point or another box.
  *
@@ -236,5 +249,9 @@ export declare const isBox: (value: unknown) => value is {
     };
 };
 export declare const aspect: (b: Box) => number;
-export declare const translate: (b: Box, t: xy.XY) => Box;
+export declare const translate: (b: Crude, t: xy.XY | direction.Direction, amount?: number) => Box;
+export declare const intersect: (a: Box, b: Box) => Box;
+export declare const area: (b: Box) => number;
+export declare const truncate: (b: Box, precision?: number) => Box;
+export declare const constructWithAlternateRoot: (x: number, y: number, width: number, height: number, currRoot: location.XY, newRoot: location.CornerXY) => Box;
 export {};

package/dist/spatial/box/index.d.ts

@@ -0,0 +1 @@
+export * as box from './box';

package/dist/spatial/{dimensions.d.ts → dimensions/dimensions.d.ts}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { dimensions, type Dimensions } from './base';
+import { dimensions, type Dimensions } from '../base';
 export { dimensions, type Dimensions };
 export declare const signed: z.ZodObject<{
     signedWidth: z.ZodNumber;

package/dist/spatial/dimensions/index.d.ts

@@ -0,0 +1 @@
+export * as dimensions from './dimensions';

package/dist/spatial/{direction.d.ts → direction/direction.d.ts}

@@ -1,4 +1,4 @@
-import { type Dimension, type Direction, type Location, type direction, type SignedDimension, type CrudeDirection } from './base';
+import { type Dimension, type Direction, type Location, type direction, type SignedDimension, type CrudeDirection } from '../base';
 export type { Direction, direction };
 export declare const crude: import("zod").ZodUnion<[import("zod").ZodEnum<["x", "y"]>, import("zod").ZodEnum<["top", "right", "bottom", "left", "center"]>]>;
 export type Crude = CrudeDirection;

package/dist/spatial/direction/index.d.ts

@@ -0,0 +1 @@
+export * as direction from './direction';

package/dist/spatial/external.d.ts

@@ -1,8 +1,9 @@
-export * as bounds from './bounds';
-export * as box from './box';
-export * as dimensions from './dimensions';
-export * as direction from './direction';
-export * as location from './location';
-export * as xy from './xy';
-export * as scale from './scale';
+export * from './bounds';
+export { box } from './box';
+export * from './dimensions';
+export * from './direction';
+export * from './location';
+export * from './xy';
+export * from './scale';
+export * from './position';
 export * as spatial from './spatial';

package/dist/spatial/location/index.d.ts

@@ -0,0 +1 @@
+export * as location from './location';

package/dist/spatial/{location.d.ts → location/location.d.ts}

@@ -1,11 +1,12 @@
 import { z } from "zod";
-import { location, type Location, X_LOCATIONS, Y_LOCATIONS, CENTER_LOCATIONS, type XLocation, type OuterLocation, type YLocation, outerLocation, type Direction, type CrudeLocation } from './base';
+import { location, type Location, X_LOCATIONS, Y_LOCATIONS, CENTER_LOCATIONS, type XLocation, type OuterLocation, type YLocation, outerLocation, type Direction, type CrudeLocation, type CenterLocation } from '../base';
 export { location, type Location, X_LOCATIONS, Y_LOCATIONS, CENTER_LOCATIONS, outerLocation as outer, };
 export declare const x: z.ZodEnum<["left", "right"]>;
 export declare const y: z.ZodEnum<["top", "bottom"]>;
 export type X = XLocation;
 export type Y = YLocation;
 export type Outer = OuterLocation;
+export type Center = CenterLocation;
 export declare const crude: z.ZodUnion<[z.ZodEnum<["x", "y"]>, z.ZodEnum<["top", "right", "bottom", "left", "center"]>, z.ZodType<String, z.ZodTypeDef, String>]>;
 export type Crude = CrudeLocation;
 export declare const construct: (cl: Crude) => Location;
@@ -13,14 +14,14 @@ export declare const swap: (cl: Crude) => Location;
 export declare const rotate90: (cl: Crude) => Location;
 export declare const direction: (cl: Crude) => Direction;
 export declare const xy: z.ZodObject<{
-    x: z.ZodEnum<["top", "right", "bottom", "left", "center"]>;
-    y: z.ZodEnum<["top", "right", "bottom", "left", "center"]>;
+    x: z.ZodUnion<[z.ZodEnum<["left", "right"]>, z.ZodEnum<["center"]>]>;
+    y: z.ZodUnion<[z.ZodEnum<["top", "bottom"]>, z.ZodEnum<["center"]>]>;
 }, "strip", z.ZodTypeAny, {
-    x: "center" | "top" | "right" | "bottom" | "left";
-    y: "center" | "top" | "right" | "bottom" | "left";
+    x: "center" | "right" | "left";
+    y: "center" | "top" | "bottom";
 }, {
-    x: "center" | "top" | "right" | "bottom" | "left";
-    y: "center" | "top" | "right" | "bottom" | "left";
+    x: "center" | "right" | "left";
+    y: "center" | "top" | "bottom";
 }>;
 export declare const corner: z.ZodObject<{
     x: z.ZodEnum<["left", "right"]>;
@@ -44,9 +45,11 @@ export declare const TOP_CENTER: XY;
 export declare const BOTTOM_CENTER: XY;
 export declare const RIGHT_CENTER: XY;
 export declare const LEFT_CENTER: XY;
+export declare const XY_LOCATIONS: readonly XY[];
 export declare const xyEquals: (a: XY, b: XY) => boolean;
+export declare const xyMatches: (a: XY, l: Partial<XY> | Location) => boolean;
 export declare const xyCouple: (a: XY) => [Location, Location];
-export declare const isX: (a: Crude) => boolean;
-export declare const isY: (a: Crude) => boolean;
+export declare const isX: (a: Crude) => a is "center" | "right" | "left";
+export declare const isY: (a: Crude) => a is "top" | "bottom";
 export declare const xyToString: (a: XY) => string;
 export declare const constructXY: (x: Crude | XY, y?: Crude) => XY;

package/dist/spatial/position/index.d.ts

@@ -0,0 +1 @@
+export * as position from './position';

package/dist/spatial/position/position.d.ts

@@ -0,0 +1,20 @@
+import { type Alignment } from '../base';
+import { box } from '../box';
+import { location } from '../location';
+import { xy } from '../xy';
+export declare const posititonSoVisible: (target: HTMLElement, p: xy.XY) => [xy.XY, boolean];
+export interface DialogProps {
+    container: box.Crude;
+    target: box.Crude;
+    dialog: box.Crude;
+    alignments?: Alignment[];
+    initial?: location.Outer | Partial<location.XY> | location.XY;
+    prefer?: Array<location.Outer | Partial<location.XY> | location.XY>;
+    disable?: Array<location.Location | Partial<location.XY>>;
+}
+export interface DialogReturn {
+    location: location.XY;
+    adjustedDialog: box.Box;
+}
+export declare const dialog: ({ container: containerCrude, target: targetCrude, dialog: dialogCrude, initial, prefer, alignments, disable, }: DialogProps) => DialogReturn;
+export declare const getRoot: (option: location.XY, alignment: Alignment) => location.XY;

package/dist/spatial/scale/index.d.ts

@@ -0,0 +1 @@
+export * as scale from './scale';

package/dist/spatial/{scale.d.ts → scale/scale.d.ts}

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import * as bounds from './bounds';
-import { type Box } from './box';
-import type * as dims from './dimensions';
-import * as location from './location';
-import * as xy from './xy';
+import * as bounds from '../bounds/bounds';
+import { type Box } from '../box/box';
+import type * as dims from '../dimensions/dimensions';
+import * as location from '../location/location';
+import * as xy from '../xy/xy';
 export declare const crudeXYTransform: z.ZodObject<{
     offset: z.ZodUnion<[z.ZodNumber, z.ZodObject<{
         x: z.ZodNumber;

package/dist/spatial/xy/index.d.ts

@@ -0,0 +1 @@
+export * as xy from './xy';

package/dist/spatial/{xy.d.ts → xy/xy.d.ts}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { clientXY, xy, type ClientXY, type XY, type Direction } from './base';
+import { clientXY, xy, type ClientXY, type XY, type Direction } from '../base';
 export { clientXY, xy, type ClientXY as Client, type XY };
 /** A crude representation of a {@link XY} coordinate as a zod schema. */
 export declare const crudeZ: z.ZodUnion<[z.ZodNumber, z.ZodObject<{
@@ -49,7 +49,7 @@ export type Crude = z.infer<typeof crudeZ>;
  * @param y - If x is a number, the y coordinate. If x is a number and this argument is
  * not given, the y coordinate is assumed to be the same as the x coordinate.
  */
-export declare const construct: (x: Crude, y?: number) => XY;
+export declare const construct: (x: Crude | Direction, y?: number) => XY;
 /** An x and y coordinate of zero */
 export declare const ZERO: {
     x: number;
@@ -83,13 +83,13 @@ export declare const scale: (c: Crude, x: number, y?: number) => XY;
 export declare const translateX: (c: Crude, x: number) => XY;
 /** @returns the given coordinate translated in the Y direction by the given amount. */
 export declare const translateY: (c: Crude, y: number) => XY;
-type TranslateOverloadOne = (a: Crude, b: Crude, ...cb: Crude[]) => XY;
-type TranslateOverloadTwo = (a: Crude, direction: Direction, value: number) => XY;
-/**
- * @returns the given coordinate translated by an arbitrary number of translation
- * coordinates.
- */
-export declare const translate: TranslateOverloadOne & TranslateOverloadTwo;
+interface Translate {
+    /** @returns the sum of the given coordinates. */
+    (a: Crude, b: Crude, ...cb: Crude[]): XY;
+    /** @returns the coordinates translated in the given direction by the given value. */
+    (a: Crude, direction: Direction, value: number): XY;
+}
+export declare const translate: Translate;
 /**
  * @returns the given coordinate the given direction set to the given value.
  * @example set({ x: 1, y: 2 }, "x", 3) // { x: 3, y: 2 }
@@ -117,3 +117,4 @@ export declare const css: (a: Crude) => {
     left: number;
     top: number;
 };
+export declare const truncate: (a: Crude, precision?: number) => XY;

package/dist/spatial/xy/xy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/telem/series.d.ts

@@ -10,6 +10,7 @@ export interface SeriesDigest {
     alignment: bounds.Bounds;
     timeRange?: string;
     length: number;
+    capacity: number;
 }
 interface BaseSeriesProps {
     dataType?: CrudeDataType;

package/dist/telem/telem.d.ts

@@ -16,7 +16,7 @@ export type DateComponents = [number?, number?, number?];
  * 1. A number representing the number of milliseconds since the Unix epoch.
  * 2. A javascript Date object.
  * 3. An array of numbers satisfying the DateComponents type, where the first element is the
- *   year, the second is the month, and the third is the day. To increaase resolution
+ *   year, the second is the month, and the third is the day. To incraase resolution
  *   when using this method, use the add method. It's important to note that this initializes
  *   a timestamp at midnight UTC, regardless of the timezone specified.
  * 4. An ISO compliant date or date time string. The time zone component is ignored.
@@ -29,9 +29,13 @@ export type DateComponents = [number?, number?, number?];
  * @example ts = new TimeStamp([2021, 1, 1]).add(1 * TimeSpan.HOUR) // 1/1/2021 at 1am UTC
  * @example ts = new TimeStamp("2021-01-01T12:30:00Z") // 1/1/2021 at 12:30pm UTC
  */
-export declare class TimeStamp extends Number implements Stringer {
+export declare class TimeStamp implements Stringer {
+    private readonly value;
+    readonly encodeValue: true;
     constructor(value?: CrudeTimeStamp, tzInfo?: TZInfo);
     private static parseDate;
+    encode(): string;
+    valueOf(): bigint;
     private static parseTimeString;
     private static parseDateTimeString;
     fString(format?: TimeStampStringFormat, tzInfo?: TZInfo): string;
@@ -159,6 +163,8 @@ export declare class TimeStamp extends Number implements Stringer {
      * JavaScript can do).
      */
     static now(): TimeStamp;
+    static max(...timestamps: CrudeTimeStamp[]): TimeStamp;
+    static min(...timestamps: CrudeTimeStamp[]): TimeStamp;
     /** @returns a new TimeStamp n nanoseconds after the unix epoch */
     static nanoseconds(value: number): TimeStamp;
     static readonly NANOSECOND: TimeStamp;
@@ -193,14 +199,29 @@ export declare class TimeStamp extends Number implements Stringer {
     /** The unix epoch */
     static readonly ZERO: TimeStamp;
     /** A zod schema for validating timestamps */
-    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+        value: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        value: bigint;
+    }, {
+        value: bigint;
+    }>, TimeStamp, {
+        value: bigint;
+    }>, z.ZodEffects<z.ZodString, TimeStamp, string>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
 }
 /** TimeSpan represents a nanosecond precision duration. */
-export declare class TimeSpan extends Number implements Stringer {
+export declare class TimeSpan implements Stringer {
+    private readonly value;
+    readonly encodeValue: true;
     constructor(value: CrudeTimeSpan);
+    encode(): string;
+    valueOf(): bigint;
+    lessThan(other: CrudeTimeSpan): boolean;
+    greaterThan(other: CrudeTimeSpan): boolean;
+    lessThanOrEqual(other: CrudeTimeSpan): boolean;
+    greaterThanOrEqual(other: CrudeTimeSpan): boolean;
     remainder(divisor: TimeSpan): TimeSpan;
     truncate(span: TimeSpan): TimeSpan;
-    multiply(factor: number): TimeSpan;
     toString(): string;
     /** @returns the decimal number of days in the timespan */
     get days(): number;
@@ -308,7 +329,15 @@ export declare class TimeSpan extends Number implements Stringer {
     /** The zero value for a TimeSpan. */
     static readonly ZERO: TimeSpan;
     /** A zod schema for validating and transforming timespans */
-    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeSpan, Number>, z.ZodEffects<z.ZodNumber, TimeSpan, number>, z.ZodType<TimeSpan, z.ZodTypeDef, TimeSpan>]>;
+    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+        value: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        value: bigint;
+    }, {
+        value: bigint;
+    }>, TimeSpan, {
+        value: bigint;
+    }>, z.ZodEffects<z.ZodString, TimeSpan, string>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeSpan, Number>, z.ZodEffects<z.ZodNumber, TimeSpan, number>, z.ZodType<TimeSpan, z.ZodTypeDef, TimeSpan>]>;
 }
 /** Rate represents a data rate in Hz. */
 export declare class Rate extends Number implements Stringer {
@@ -465,6 +494,14 @@ export declare class TimeRange implements Stringer {
     equals(other: TimeRange): boolean;
     toString(): string;
     toPrettyString(): string;
+    /**
+     * Checks if if the two time ranges overlap. If the two time ranges are equal, returns
+     * true.  If the start of one range is equal to the end of the other, returns false.
+     * Just follow the rule [start, end) i.e. start is inclusive and end is exclusive.
+     *
+     * @param other - The other TimeRange to compare to.
+     * @returns True if the two TimeRanges overlap, false otherwise.
+     */
     overlapsWith(other: TimeRange): boolean;
     contains(other: TimeRange): boolean;
     contains(ts: CrudeTimeStamp): boolean;
@@ -477,17 +514,49 @@ export declare class TimeRange implements Stringer {
     static readonly ZERO: TimeRange;
     /** A zod schema for validating and transforming time ranges */
     static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
-        start: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
-        end: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+        start: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+            value: z.ZodBigInt;
+        }, "strip", z.ZodTypeAny, {
+            value: bigint;
+        }, {
+            value: bigint;
+        }>, TimeStamp, {
+            value: bigint;
+        }>, z.ZodEffects<z.ZodString, TimeStamp, string>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+        end: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+            value: z.ZodBigInt;
+        }, "strip", z.ZodTypeAny, {
+            value: bigint;
+        }, {
+            value: bigint;
+        }>, TimeStamp, {
+            value: bigint;
+        }>, z.ZodEffects<z.ZodString, TimeStamp, string>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
     }, "strip", z.ZodTypeAny, {
         start: TimeStamp;
         end: TimeStamp;
     }, {
-        start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
-        end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+        start: (string | number | Number | TimeStamp | {
+            value: bigint;
+        }) & (string | number | Number | TimeStamp | {
+            value: bigint;
+        } | undefined);
+        end: (string | number | Number | TimeStamp | {
+            value: bigint;
+        }) & (string | number | Number | TimeStamp | {
+            value: bigint;
+        } | undefined);
     }>, TimeRange, {
-        start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
-        end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+        start: (string | number | Number | TimeStamp | {
+            value: bigint;
+        }) & (string | number | Number | TimeStamp | {
+            value: bigint;
+        } | undefined);
+        end: (string | number | Number | TimeStamp | {
+            value: bigint;
+        }) & (string | number | Number | TimeStamp | {
+            value: bigint;
+        } | undefined);
     }>, z.ZodType<TimeRange, z.ZodTypeDef, TimeRange>]>;
 }
 /** DataType is a string that represents a data type. */
@@ -562,6 +631,13 @@ export declare class Size extends Number implements Stringer {
     smallerThan(other: CrudeSize): boolean;
     add(other: CrudeSize): Size;
     sub(other: CrudeSize): Size;
+    truncate(span: CrudeSize): Size;
+    remainder(span: CrudeSize): Size;
+    get gigabytes(): number;
+    get megabytes(): number;
+    get kilobytes(): number;
+    get terabytes(): number;
+    toString(): string;
     /**
      * Creates a Size from the given number of bytes.
      *
@@ -611,11 +687,11 @@ export declare class Size extends Number implements Stringer {
     static readonly ZERO: Size;
     /** A zod schema for a Size. */
     static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodNumber, Size, number>, z.ZodType<Size, z.ZodTypeDef, Size>]>;
-    isZero(): boolean;
+    get isZero(): boolean;
 }
-export type CrudeTimeStamp = TimeStamp | TimeSpan | number | Date | string | DateComponents | Number;
+export type CrudeTimeStamp = bigint | BigInt | TimeStamp | TimeSpan | number | Date | string | DateComponents | Number;
 export type TimeStampT = number;
-export type CrudeTimeSpan = TimeSpan | TimeStamp | number | Number;
+export type CrudeTimeSpan = bigint | BigInt | TimeSpan | TimeStamp | number | Number;
 export type TimeSpanT = number;
 export type CrudeRate = Rate | number | Number;
 export type RateT = number;