@synnaxlabs/x 0.7.0

package/dist/telem/telem.d.ts

@@ -0,0 +1,633 @@
+import { z } from "zod";
+import { type Stringer } from '../primitive';
+export type TZInfo = "UTC" | "local";
+export type TimeStampStringFormat = "ISO" | "ISODate" | "ISOTime" | "time" | "preciseTime" | "date" | "preciseDate" | "shortDate" | "dateTime";
+export type DateComponents = [number?, number?, number?];
+/**
+ * Represents a UTC timestamp. Synnax uses a nanosecond precision int64 timestamp.
+ *
+ * DISCLAIMER: JavaScript stores all numbers as 64-bit floating point numbers, so we expect a
+ * expect a precision drop from nanoseconds to quarter microseconds when communicating
+ * with the server. If this is a problem, please file an issue with the Synnax team.
+ * Caveat emptor.
+ *
+ * @param value - The timestamp value to parse. This can be any of the following:
+ *
+ * 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
+ *   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.
+ *
+ * @param tzInfo - The timezone to use when parsing the timestamp. This can be either "UTC" or
+ * "local". This parameter is ignored if the value is a Date object or a DateComponents array.
+ *
+ * @example ts = new TimeStamp(1 * TimeSpan.HOUR) // 1 hour after the Unix epoch
+ * @example ts = new TimeStamp([2021, 1, 1]) // 1/1/2021 at midnight UTC
+ * @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 {
+    constructor(value?: CrudeTimeStamp, tzInfo?: TZInfo);
+    private static parseDate;
+    private static parseTimeString;
+    private static parseDateTimeString;
+    fString(format?: TimeStampStringFormat, tzInfo?: TZInfo): string;
+    private toISOString;
+    private timeString;
+    private dateString;
+    static get utcOffset(): TimeSpan;
+    /**
+     * @returns a TimeSpan representing the amount time elapsed since
+     * the other timestamp.
+     * @param other - The other timestamp.
+     */
+    static since(other: TimeStamp): TimeSpan;
+    /** @returns A JavaScript Date object representing the TimeStamp. */
+    date(): Date;
+    /**
+     * Checks if the TimeStamp is equal to another TimeStamp.
+     *
+     * @param other - The other TimeStamp to compare to.
+     * @returns True if the TimeStamps are equal, false otherwise.
+     */
+    equals(other: CrudeTimeStamp): boolean;
+    /**
+     * Creates a TimeSpan representing the duration between the two timestamps.
+     *
+     * @param other - The other TimeStamp to compare to.
+     * @returns A TimeSpan representing the duration between the two timestamps.
+     *   The span is guaranteed to be positive.
+     */
+    span(other: CrudeTimeStamp): TimeSpan;
+    /**
+     * Creates a TimeRange spanning the given TimeStamp.
+     *
+     * @param other - The other TimeStamp to compare to.
+     * @returns A TimeRange spanning the given TimeStamp that is guaranteed to be
+     *   valid, regardless of the TimeStamp order.
+     */
+    range(other: CrudeTimeStamp): TimeRange;
+    /**
+     * Creates a TimeRange starting at the TimeStamp and spanning the given
+     * TimeSpan.
+     *
+     * @param other - The TimeSpan to span.
+     * @returns A TimeRange starting at the TimeStamp and spanning the given
+     *   TimeSpan. The TimeRange is guaranteed to be valid.
+     */
+    spanRange(other: CrudeTimeSpan): TimeRange;
+    /**
+     * Checks if the TimeStamp represents the unix epoch.
+     *
+     * @returns True if the TimeStamp represents the unix epoch, false otherwise.
+     */
+    get isZero(): boolean;
+    /**
+     * Checks if the TimeStamp is after the given TimeStamp.
+     *
+     * @param other - The other TimeStamp to compare to.
+     * @returns True if the TimeStamp is after the given TimeStamp, false
+     *   otherwise.
+     */
+    after(other: CrudeTimeStamp): boolean;
+    /**
+     * Checks if the TimeStamp is after or equal to the given TimeStamp.
+     *
+     * @param other - The other TimeStamp to compare to.
+     * @returns True if the TimeStamp is after or equal to the given TimeStamp,
+     *   false otherwise.
+     */
+    afterEq(other: CrudeTimeStamp): boolean;
+    /**
+     * Checks if the TimeStamp is before the given TimeStamp.
+     *
+     * @param other - The other TimeStamp to compare to.
+     * @returns True if the TimeStamp is before the given TimeStamp, false
+     *   otherwise.
+     */
+    before(other: CrudeTimeStamp): boolean;
+    /**
+     * Checks if TimeStamp is before or equal to the current timestamp.
+     *
+     * @param other - The other TimeStamp to compare to.
+     * @returns True if TimeStamp is before or equal to the current timestamp,
+     *   false otherwise.
+     */
+    beforeEq(other: CrudeTimeStamp): boolean;
+    /**
+     * Adds a TimeSpan to the TimeStamp.
+     *
+     * @param span - The TimeSpan to add.
+     * @returns A new TimeStamp representing the sum of the TimeStamp and
+     *   TimeSpan.
+     */
+    add(span: CrudeTimeSpan): TimeStamp;
+    /**
+     * Subtracts a TimeSpan from the TimeStamp.
+     *
+     * @param span - The TimeSpan to subtract.
+     * @returns A new TimeStamp representing the difference of the TimeStamp and
+     *   TimeSpan.
+     */
+    sub(span: CrudeTimeSpan): TimeStamp;
+    /**
+     * @returns The number of milliseconds since the unix epoch.
+     */
+    milliseconds(): number;
+    toString(): string;
+    /**
+     * @returns A new TimeStamp that is the remainder of the TimeStamp divided by the
+     * given span. This is useful in cases where you want only part of a TimeStamp's value
+     * i.e. the hours, minutes, seconds, milliseconds, microseconds, and nanoseconds but
+     * not the days, years, etc.
+     *
+     * @param divisor - The TimeSpan to divide by. Must be an even TimeSpan or TimeStamp. Even
+     * means it must be a day, hour, minute, second, millisecond, or microsecond, etc.
+     *
+     * @example TimeStamp.now().remainder(TimeStamp.DAY) // => TimeStamp representing the current day
+     */
+    remainder(divisor: TimeSpan | TimeStamp): TimeStamp;
+    /** @returns true if the day portion TimeStamp is today, false otherwise. */
+    get isToday(): boolean;
+    truncate(span: TimeSpan | TimeStamp): TimeStamp;
+    /**
+     * @returns A new TimeStamp representing the current time in UTC. It's important to
+     * note that this TimeStamp is only accurate to the millisecond level (that's the best
+     * JavaScript can do).
+     */
+    static now(): TimeStamp;
+    /** @returns a new TimeStamp n nanoseconds after the unix epoch */
+    static nanoseconds(value: number): TimeStamp;
+    static readonly NANOSECOND: TimeStamp;
+    /** @returns a new TimeStamp n microseconds after the unix epoch */
+    static microseconds(value: number): TimeStamp;
+    /** One microsecond after the unix epoch */
+    static readonly MICROSECOND: TimeStamp;
+    /** @returns a new TimeStamp n milliseconds after the unix epoch */
+    static milliseconds(value: number): TimeStamp;
+    /** One millisecond after the unix epoch */
+    static readonly MILLISECOND: TimeStamp;
+    /** @returns a new TimeStamp n seconds after the unix epoch */
+    static seconds(value: number): TimeStamp;
+    /** One second after the unix epoch */
+    static readonly SECOND: TimeStamp;
+    /** @returns a new TimeStamp n minutes after the unix epoch */
+    static minutes(value: number): TimeStamp;
+    /** One minute after the unix epoch */
+    static readonly MINUTE: TimeStamp;
+    /** @returns a new TimeStamp n hours after the unix epoch */
+    static hours(value: number): TimeStamp;
+    /** One hour after the unix epoch */
+    static readonly HOUR: TimeStamp;
+    /** @returns a new TimeStamp n days after the unix epoch */
+    static days(value: number): TimeStamp;
+    /** One day after the unix epoch */
+    static readonly DAY: TimeStamp;
+    /** The maximum possible value for a timestamp */
+    static readonly MAX: TimeStamp;
+    /** The minimum possible value for a timestamp */
+    static readonly MIN: TimeStamp;
+    /** 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>]>;
+}
+/** TimeSpan represents a nanosecond precision duration. */
+export declare class TimeSpan extends Number implements Stringer {
+    constructor(value: CrudeTimeSpan);
+    remainder(divisor: TimeSpan): TimeSpan;
+    truncate(span: TimeSpan): TimeSpan;
+    toString(): string;
+    /** @returns the decimal number of days in the timespan */
+    get days(): number;
+    /** @returns the decimal number of hours in the timespan */
+    get hours(): number;
+    /** @returns the decimal number of minutes in the timespan */
+    get minutes(): number;
+    /** @returns The number of seconds in the TimeSpan. */
+    get seconds(): number;
+    /** @returns The number of milliseconds in the TimeSpan. */
+    get milliseconds(): number;
+    get microseconds(): number;
+    get nanoseconds(): number;
+    /**
+     * Checks if the TimeSpan represents a zero duration.
+     *
+     * @returns True if the TimeSpan represents a zero duration, false otherwise.
+     */
+    get isZero(): boolean;
+    /**
+     * Checks if the TimeSpan is equal to another TimeSpan.
+     *
+     * @returns True if the TimeSpans are equal, false otherwise.
+     */
+    equals(other: CrudeTimeSpan): boolean;
+    /**
+     * Adds a TimeSpan to the TimeSpan.
+     *
+     * @returns A new TimeSpan representing the sum of the two TimeSpans.
+     */
+    add(other: CrudeTimeSpan): TimeSpan;
+    /**
+     * Creates a TimeSpan representing the duration between the two timestamps.
+     *
+     * @param other
+     */
+    sub(other: CrudeTimeSpan): TimeSpan;
+    /**
+     * Creates a TimeSpan representing the given number of nanoseconds.
+     *
+     * @param value - The number of nanoseconds.
+     * @returns A TimeSpan representing the given number of nanoseconds.
+     */
+    static nanoseconds(value?: number): TimeSpan;
+    /** A nanosecond. */
+    static readonly NANOSECOND: TimeSpan;
+    /**
+     * Creates a TimeSpan representing the given number of microseconds.
+     *
+     * @param value - The number of microseconds.
+     * @returns A TimeSpan representing the given number of microseconds.
+     */
+    static microseconds(value?: number): TimeSpan;
+    /** A microsecond. */
+    static readonly MICROSECOND: TimeSpan;
+    /**
+     * Creates a TimeSpan representing the given number of milliseconds.
+     *
+     * @param value - The number of milliseconds.
+     * @returns A TimeSpan representing the given number of milliseconds.
+     */
+    static milliseconds(value?: number): TimeSpan;
+    /** A millisecond. */
+    static readonly MILLISECOND: TimeSpan;
+    /**
+     * Creates a TimeSpan representing the given number of seconds.
+     *
+     * @param value - The number of seconds.
+     * @returns A TimeSpan representing the given number of seconds.
+     */
+    static seconds(value?: number): TimeSpan;
+    /** A second. */
+    static readonly SECOND: TimeSpan;
+    /**
+     * Creates a TimeSpan representing the given number of minutes.
+     *
+     * @param value - The number of minutes.
+     * @returns A TimeSpan representing the given number of minutes.
+     */
+    static minutes(value: number): TimeSpan;
+    /** A minute. */
+    static readonly MINUTE: TimeSpan;
+    /**
+     * Creates a TimeSpan representing the given number of hours.
+     *
+     * @param value - The number of hours.
+     * @returns A TimeSpan representing the given number of hours.
+     */
+    static hours(value: number): TimeSpan;
+    /** Represents an hour. */
+    static readonly HOUR: TimeSpan;
+    /**
+     * Creates a TimeSpan representing the given number of days.
+     *
+     * @param value - The number of days.
+     * @returns A TimeSpan representing the given number of days.
+     */
+    static days(value: number): TimeSpan;
+    /** Represents a day. */
+    static readonly DAY: TimeSpan;
+    /** The maximum possible value for a TimeSpan. */
+    static readonly MAX: TimeSpan;
+    /** The minimum possible value for a TimeSpan. */
+    static readonly MIN: TimeSpan;
+    /** 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>]>;
+}
+/** Rate represents a data rate in Hz. */
+export declare class Rate extends Number implements Stringer {
+    constructor(value: CrudeRate);
+    /** @returns a pretty string representation of the rate in the format "X Hz". */
+    toString(): string;
+    /** @returns The number of seconds in the Rate. */
+    equals(other: CrudeRate): boolean;
+    /**
+     * Calculates the period of the Rate as a TimeSpan.
+     *
+     * @returns A TimeSpan representing the period of the Rate.
+     */
+    get period(): TimeSpan;
+    /**
+     * Calculates the number of samples in the given TimeSpan at this rate.
+     *
+     * @param duration - The duration to calculate the sample count from.
+     * @returns The number of samples in the given TimeSpan at this rate.
+     */
+    sampleCount(duration: CrudeTimeSpan): number;
+    /**
+     * Calculates the number of bytes in the given TimeSpan at this rate.
+     *
+     * @param span - The duration to calculate the byte count from.
+     * @param density - The density of the data in bytes per sample.
+     * @returns The number of bytes in the given TimeSpan at this rate.
+     */
+    byteCount(span: CrudeTimeSpan, density: CrudeDensity): number;
+    /**
+     * Calculates a TimeSpan given the number of samples at this rate.
+     *
+     * @param sampleCount - The number of samples in the span.
+     * @returns A TimeSpan that corresponds to the given number of samples.
+     */
+    span(sampleCount: number): TimeSpan;
+    /**
+     * Calculates a TimeSpan given the number of bytes at this rate.
+     *
+     * @param size - The number of bytes in the span.
+     * @param density - The density of the data in bytes per sample.
+     * @returns A TimeSpan that corresponds to the given number of bytes.
+     */
+    byteSpan(size: Size, density: CrudeDensity): TimeSpan;
+    /**
+     * Creates a Rate representing the given number of Hz.
+     *
+     * @param value - The number of Hz.
+     * @returns A Rate representing the given number of Hz.
+     */
+    static hz(value: number): Rate;
+    /**
+     * Creates a Rate representing the given number of kHz.
+     *
+     * @param value - The number of kHz.
+     * @returns A Rate representing the given number of kHz.
+     */
+    static khz(value: number): Rate;
+    /** A zod schema for validating and transforming rates */
+    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodNumber, Rate, number>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, Rate, Number>, z.ZodType<Rate, z.ZodTypeDef, Rate>]>;
+}
+/** Density represents the number of bytes in a value. */
+export declare class Density extends Number implements Stringer {
+    /**
+     * Creates a Density representing the given number of bytes per value.
+     *
+     * @class
+     * @param value - The number of bytes per value.
+     * @returns A Density representing the given number of bytes per value.
+     */
+    constructor(value: CrudeDensity);
+    length(size: Size): number;
+    size(sampleCount: number): Size;
+    /** Unknown/Invalid Density. */
+    static readonly UNKNOWN: Density;
+    /** 128 bits per value. */
+    static readonly BIT128: Density;
+    /** 64 bits per value. */
+    static readonly BIT64: Density;
+    /** 32 bits per value. */
+    static readonly BIT32: Density;
+    /** 16 bits per value. */
+    static readonly BIT16: Density;
+    /** 8 bits per value. */
+    static readonly BIT8: Density;
+    /** A zod schema for validating and transforming densities */
+    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodNumber, Density, number>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, Density, Number>, z.ZodType<Density, z.ZodTypeDef, Density>]>;
+}
+/**
+ * TimeRange is a range of time marked by a start and end timestamp. A TimeRange
+ * is start inclusive and end exclusive.
+ *
+ * @property start - A TimeStamp representing the start of the range.
+ * @property end - A Timestamp representing the end of the range.
+ */
+export declare class TimeRange implements Stringer {
+    /**
+     * The starting TimeStamp of the TimeRange.
+     *
+     * Note that this value is not guaranteed to be before or equal to the ending value.
+     * To ensure that this is the case, call TimeRange.make_valid().
+     *
+     * In most cases, operations should treat start as inclusive.
+     */
+    start: TimeStamp;
+    /**
+     * The starting TimeStamp of the TimeRange.
+     *
+     * Note that this value is not guaranteed to be before or equal to the ending value.
+     * To ensure that this is the case, call TimeRange.make_valid().
+     *
+     * In most cases, operations should treat end as exclusive.
+     */
+    end: TimeStamp;
+    /**
+     * Creates a TimeRange from the given start and end TimeStamps.
+     *
+     * @param start - A TimeStamp representing the start of the range.
+     * @param end - A TimeStamp representing the end of the range.
+     */
+    constructor(start: CrudeTimeStamp, end: CrudeTimeStamp);
+    /** @returns The TimeSpan occupied by the TimeRange. */
+    get span(): TimeSpan;
+    /**
+     * Checks if the timestamp is valid i.e. the start is before the end.
+     *
+     * @returns True if the TimeRange is valid.
+     */
+    get isValid(): boolean;
+    /**
+     * Makes sure the TimeRange is valid i.e. the start is before the end.
+     *
+     * @returns A TimeRange that is valid.
+     */
+    makeValid(): TimeRange;
+    /**
+     * Checks if the TimeRange has a zero span.
+     *
+     * @returns True if the TimeRange has a zero span.
+     */
+    get isZero(): boolean;
+    /**
+     * Creates a new TimeRange with the start and end swapped.
+     *
+     * @returns A TimeRange with the start and end swapped.
+     */
+    swap(): TimeRange;
+    /**
+     * Checks if the TimeRange is equal to the given TimeRange.
+     *
+     * @param other - The TimeRange to compare to.
+     * @returns True if the TimeRange is equal to the given TimeRange.
+     */
+    equals(other: TimeRange): boolean;
+    toString(): string;
+    toPrettyString(): string;
+    overlapsWith(other: TimeRange): boolean;
+    contains(other: TimeRange): boolean;
+    contains(ts: CrudeTimeStamp): boolean;
+    /** The maximum possible time range. */
+    static readonly MAX: TimeRange;
+    /** The minimum possible time range. */
+    static readonly MIN: TimeRange;
+    /** A zero time range. */
+    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>]>;
+    }, "strip", z.ZodTypeAny, {
+        start: TimeStamp;
+        end: TimeStamp;
+    }, {
+        start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+        end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+    }>, TimeRange, {
+        start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+        end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+    }>, z.ZodType<TimeRange, z.ZodTypeDef, TimeRange>]>;
+}
+/** DataType is a string that represents a data type. */
+export declare class DataType extends String implements Stringer {
+    constructor(value: CrudeDataType);
+    /**
+     * @returns the TypedArray constructor for the DataType.
+     */
+    get Array(): NativeTypedArrayConstructor;
+    equals(other: DataType): boolean;
+    /** @returns a string representation of the DataType. */
+    toString(): string;
+    get density(): Density;
+    /**
+     * Checks whether the given TypedArray is of the same type as the DataType.
+     *
+     * @param array - The TypedArray to check.
+     * @returns True if the TypedArray is of the same type as the DataType.
+     */
+    checkArray(array: NativeTypedArray): boolean;
+    toJSON(): string;
+    get usesBigInt(): boolean;
+    /** Represents an Unknown/Invalid DataType. */
+    static readonly UNKNOWN: DataType;
+    /** Represents a 64-bit floating point value. */
+    static readonly FLOAT64: DataType;
+    /** Represents a 32-bit floating point value. */
+    static readonly FLOAT32: DataType;
+    /** Represents a 64-bit signed integer value. */
+    static readonly INT64: DataType;
+    /** Represents a 32-bit signed integer value. */
+    static readonly INT32: DataType;
+    /** Represents a 16-bit signed integer value. */
+    static readonly INT16: DataType;
+    /** Represents a 8-bit signed integer value. */
+    static readonly INT8: DataType;
+    /** Represents a 64-bit unsigned integer value. */
+    static readonly UINT64: DataType;
+    /** Represents a 32-bit unsigned integer value. */
+    static readonly UINT32: DataType;
+    /** Represents a 16-bit unsigned integer value. */
+    static readonly UINT16: DataType;
+    /** Represents a 8-bit unsigned integer value. */
+    static readonly UINT8: DataType;
+    /** Represents a 64-bit unix epoch. */
+    static readonly TIMESTAMP: DataType;
+    /** Represents a UUID data type */
+    static readonly UUID: DataType;
+    /** Represents a string data type. Strings have an unknown density, and are separate
+     * by a newline character. */
+    static readonly STRING: DataType;
+    /** Represents a JSON data type. JSON has an unknown density, and is separated by a
+     * newline character. */
+    static readonly JSON: DataType;
+    static readonly ARRAY_CONSTRUCTORS: Map<string, NativeTypedArrayConstructor>;
+    static readonly ARRAY_CONSTRUCTOR_DATA_TYPES: Map<string, DataType>;
+    static readonly DENSITIES: Map<string, Density>;
+    static readonly BIG_INT_TYPES: DataType[];
+    /** A zod schema for a DataType. */
+    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodString, DataType, string>, z.ZodType<DataType, z.ZodTypeDef, DataType>]>;
+}
+/**
+ * The Size of an elementy in bytes.
+ */
+export declare class Size extends Number implements Stringer {
+    constructor(value: CrudeSize);
+    /** @returns true if the Size is larger than the other size. */
+    largerThan(other: CrudeSize): boolean;
+    /** @returns true if the Size is smaller than the other sisze. */
+    smallerThan(other: CrudeSize): boolean;
+    add(other: CrudeSize): Size;
+    sub(other: CrudeSize): Size;
+    /**
+     * Creates a Size from the given number of bytes.
+     *
+     * @param value - The number of bytes.
+     * @returns A Size representing the given number of bytes.
+     */
+    static bytes(value?: CrudeSize): Size;
+    /** A single byte */
+    static readonly BYTE: Size;
+    /**
+     * Creates a Size from the given number if kilobytes.
+     *
+     * @param value - The number of kilobytes.
+     * @returns A Size representing the given number of kilobytes.
+     */
+    static kilobytes(value?: CrudeSize): Size;
+    /** A kilobyte */
+    static readonly KILOBYTE: Size;
+    /**
+     * Creates a Size from the given number of megabytes.
+     *
+     * @param value - The number of megabytes.
+     * @returns A Size representing the given number of megabytes.
+     */
+    static megabytes(value?: CrudeSize): Size;
+    /** A megabyte */
+    static readonly MEGABYTE: Size;
+    /**
+     * Creates a Size from the given number of gigabytes.
+     *
+     * @param value - The number of gigabytes.
+     * @returns A Size representing the given number of gigabytes.
+     */
+    static gigabytes(value?: CrudeSize): Size;
+    /** A gigabyte */
+    static readonly GIGABYTE: Size;
+    /**
+     * Creates a Size from the given number of terabytes.
+     *
+     * @param value - The number of terabytes.
+     * @returns  A Size representing the given number of terabytes.
+     */
+    static terabytes(value: CrudeSize): Size;
+    /** A terabyte. */
+    static readonly TERABYTE: Size;
+    /** The zero value for Size */
+    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;
+}
+export type CrudeTimeStamp = TimeStamp | TimeSpan | number | Date | string | DateComponents | Number;
+export type TimeStampT = number;
+export type CrudeTimeSpan = TimeSpan | TimeStamp | number | Number;
+export type TimeSpanT = number;
+export type CrudeRate = Rate | number | Number;
+export type RateT = number;
+export type CrudeDensity = Density | number | Number;
+export type DensityT = number;
+export type CrudeDataType = DataType | string | NativeTypedArray;
+export type DataTypeT = string;
+export type CrudeSize = Size | number | Number;
+export type SizeT = number;
+export interface CrudeTimeRange {
+    start: TimeStampT;
+    end: TimeStampT;
+}
+export declare const nativeTypedArray: z.ZodUnion<[z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>, z.ZodType<Uint16Array, z.ZodTypeDef, Uint16Array>, z.ZodType<Uint32Array, z.ZodTypeDef, Uint32Array>, z.ZodType<BigUint64Array, z.ZodTypeDef, BigUint64Array>, z.ZodType<Float32Array, z.ZodTypeDef, Float32Array>, z.ZodType<Float64Array, z.ZodTypeDef, Float64Array>, z.ZodType<Int8Array, z.ZodTypeDef, Int8Array>, z.ZodType<Int16Array, z.ZodTypeDef, Int16Array>, z.ZodType<Int32Array, z.ZodTypeDef, Int32Array>, z.ZodType<BigInt64Array, z.ZodTypeDef, BigInt64Array>]>;
+export type NativeTypedArray = z.infer<typeof nativeTypedArray>;
+type NativeTypedArrayConstructor = Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | BigUint64ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | BigInt64ArrayConstructor;
+type TelemValue = number | bigint;
+export declare const convertDataType: (source: DataType, target: DataType, value: TelemValue, offset?: number | bigint) => TelemValue;
+export {};

package/dist/telem/telem.spec.d.ts

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

package/dist/toArray.d.ts

@@ -0,0 +1 @@
+export declare const toArray: <T>(value: T | T[]) => T[];

package/dist/transform.d.ts

@@ -0,0 +1 @@
+export type ArrayTransform<E = unknown, R = E> = (data: E[]) => R[];

package/dist/unique.d.ts

@@ -0,0 +1 @@
+export declare const unique: <V>(values: V[] | readonly V[]) => V[];

package/dist/url/index.d.ts

@@ -0,0 +1 @@
+export * from "./url";