@synnaxlabs/x 0.7.0

package/.eslintrc.cjs

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2023 Synnax Labs, Inc.
+ *
+ * Use of this software is governed by the Business Source License included in the file
+ * licenses/BSL.txt.
+ *
+ * As of the Change Date specified in that file, in accordance with the Business Source
+ * License, use of this software will be governed by the Apache License, Version 2.0,
+ * included in the file licenses/APL.txt.
+ */
+
+module.exports = {
+    root: true,
+    extends: ["synnaxlabs"],
+    parserOptions: {
+        project: "./tsconfig.json",
+    },
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,16 @@
+
+> @synnaxlabs/x@0.7.0 build /Users/emilianobonilla/Desktop/synnaxlabs/synnax/x/ts
+> vite build
+
+vite v5.0.10 building for production...
+transforming...
+✓ 112 modules transformed.
+rendering chunks...
+
+[vite:dts] Start generate declaration files...
+computing gzip size...
+dist/x.es.js  282.61 kB │ gzip: 52.80 kB │ map: 575.28 kB
+[vite:dts] Declaration files built in 1170ms.
+
+dist/x.cjs.js  283.44 kB │ gzip: 52.94 kB │ map: 575.40 kB
+✓ built in 1.57s

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "cmake.configureOnOpen": false
+}

package/LICENSE

@@ -0,0 +1,4 @@
+Source code in this repository is licensed under the Business Source License 1.1 (BSL).
+A copy of the license can be found in the licenses/BSL.txt file. Source code in a given
+file is licensed under the BSL and the copyright belongs to Synnax Labs, Inc. unless
+otherwise noted at the beginning of the file.

package/README.md

@@ -0,0 +1,44 @@
+# Typescript X - Common Utilities for the Synnax Codebase
+
+This directory contains the source for the `@synnaxlabs/x` package, which contains 
+common utilities dependend on by other packages in the Synnax codebase.
+
+## Installation
+
+With NPM:
+
+```
+npm install @synnaxlabs/x
+```
+
+With Yarn:
+
+```
+yarn add @synnaxlabs/x
+```
+
+With PNPM:
+
+```bash
+pnpm add @synnaxlabs/x
+```
+
+## Running the test suite
+
+```bash
+pnpm test
+```
+
+## Building the package
+
+From the root directory of the synnax repository, run:
+
+```bash
+pnpm build:x
+```
+
+
+
+
+
+

package/dist/binary/encoder.d.ts

@@ -0,0 +1,59 @@
+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.
+ */
+export interface EncoderDecoder {
+    /** The HTTP content type of the encoder */
+    contentType: string;
+    /**
+     * Encodes the given payload into a binary representation.
+     *
+     * @param payload - The payload to encode.
+     * @returns An ArrayBuffer containing the encoded payload.
+     */
+    encode: (payload: unknown) => ArrayBuffer;
+    /**
+     * Decodes the given binary representation into a type checked payload.
+     *
+     * @param data - The data to decode.
+     * @param schema - The schema to decode the data with.
+     */
+    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;
+    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/binary/encoder.spec.d.ts

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

package/dist/binary/index.d.ts

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

package/dist/case.d.ts

@@ -0,0 +1,5 @@
+export declare namespace Case {
+    const toSnake: <T>(entity: T) => Record<string, T[keyof T]>;
+    const toCamel: <T extends Partial<Record<keyof T, unknown>>>(entity: T) => Record<string, T[keyof T]>;
+    const capitalize: (str: string) => string;
+}

package/dist/change/change.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export type Variant = "set" | "delete";
+export declare const Z: <V extends z.ZodTypeAny>(value: V) => z.ZodObject<{
+    variant: z.ZodEnum<["set", "delete"]>;
+    key: z.ZodString;
+    value: V;
+}, "strip", z.ZodTypeAny, { [k_1 in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    variant: z.ZodEnum<["set", "delete"]>;
+    key: z.ZodString;
+    value: V;
+}>, "key" | "variant" | (undefined extends V["_output"] ? never : "value")>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    variant: z.ZodEnum<["set", "delete"]>;
+    key: z.ZodString;
+    value: V;
+}>, "key" | "variant" | (undefined extends V["_output"] ? never : "value")>[k_1]; }, { [k_2 in keyof z.baseObjectInputType<{
+    variant: z.ZodEnum<["set", "delete"]>;
+    key: z.ZodString;
+    value: V;
+}>]: z.baseObjectInputType<{
+    variant: z.ZodEnum<["set", "delete"]>;
+    key: z.ZodString;
+    value: V;
+}>[k_2]; }>;
+export type Change<K, V> = {
+    variant: "set";
+    key: K;
+    value: V;
+} | {
+    variant: "delete";
+    key: K;
+    value?: V;
+};

package/dist/change/index.d.ts

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

package/dist/clamp.d.ts

@@ -0,0 +1 @@
+export declare const clamp: (value: number, min?: number, max?: number) => number;

package/dist/compare/compare.d.ts

@@ -0,0 +1,39 @@
+import { type Primitive, type PrimitiveRecord } from '../primitive';
+import { type spatial } from '../spatial';
+export type CompareF<T> = (a: T, b: T) => number;
+/**
+ * Creates the appropriate compare function for sorting the given
+ * primitive type.
+ *
+ * @param v The primitive value to create a compare function for.
+ * This is used to determine the type of comparison to perform.
+ * @param reverse Whether to reverse the sort order.
+ */
+export declare const newF: <T extends Primitive>(v: T, reverse?: boolean) => CompareF<T>;
+/**
+ * Creates a compare function that compares the field of the given object.
+ *
+ * @param key The key of the field to compare.
+ * @param value The object to compare the field of. This is used to determine the type of
+ * comparison to perform.
+ * @param reverse Whether to reverse the sort order.
+ */
+export declare const newFieldF: <T extends PrimitiveRecord>(key: keyof T, value: T, reverse?: boolean) => CompareF<T>;
+/**
+ * Compares the two primitive arrays.
+ * @param a The first array to compare.
+ * @param b The second array to compare.
+ * @returns The array with the greater length if the array lengths are not equal. If the
+ * arrays are the same length, returns 0 if all elements are equal, otherwise returns -1.
+ */
+export declare const primitiveArrays: <T extends Primitive>(a: readonly T[] | T[], b: readonly T[] | T[]) => number;
+export declare const unorderedPrimitiveArrays: <T extends Primitive>(a: readonly T[] | T[], b: readonly T[] | T[]) => number;
+export declare const order: (a: spatial.Order, b: spatial.Order) => number;
+/** @returns the reverse of the given compare function. */
+export declare const reverseF: <T>(f: CompareF<T>) => CompareF<T>;
+/** The equal return value of a compare function. */
+export declare const EQUAL = 0;
+/** The less than return value of a compare function. */
+export declare const LESS_THAN = -1;
+/** The greater than return value of a compare function. */
+export declare const GREATER_THAN = 1;

package/dist/compare/index.d.ts

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

package/dist/debounce.d.ts

@@ -0,0 +1,2 @@
+export declare const debounce: <F extends (...args: any[]) => void>(func: F, waitFor: number) => F;
+export declare const throttle: <F extends (...args: any[]) => void>(func: F, waitFor: number) => F;

package/dist/deep/copy.d.ts

@@ -0,0 +1 @@
+export declare const copy: <T extends Partial<Record<keyof T, unknown>>>(obj: T) => T;

package/dist/deep/delete.d.ts

@@ -0,0 +1,2 @@
+import { type Key } from '../deep/key';
+export declare const deleteD: <T extends Partial<Record<keyof T, unknown>>, D extends number = 5>(target: T, ...keys: Key<T, D>[]) => T;

package/dist/deep/delete.spec.d.ts

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

package/dist/deep/equal.d.ts

@@ -0,0 +1,8 @@
+import { type UnknownRecord } from '../record';
+import { Primitive } from '../primitive';
+type DeepEqualBaseRecord = UnknownRecord | {
+    equals?: (other: any) => boolean;
+};
+export declare const equal: <T extends DeepEqualBaseRecord | DeepEqualBaseRecord[] | Primitive[]>(a: T, b: T) => boolean;
+export declare const partialEqual: <T extends Partial<Record<keyof T, unknown>>>(base: T, partial: Partial<T>) => boolean;
+export {};

package/dist/deep/equal.spec.d.ts

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

package/dist/deep/external.d.ts

@@ -0,0 +1,7 @@
+export * from '../deep/copy';
+export * from '../deep/delete';
+export * from '../deep/key';
+export * from '../deep/merge';
+export * from '../deep/partial';
+export * from '../deep/equal';
+export * from '../deep/memo';

package/dist/deep/index.d.ts

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

package/dist/deep/key.d.ts

@@ -0,0 +1,30 @@
+import { type Join } from '../join';
+type Prev = [
+    never,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    ...Array<0>
+];
+export type Key<T, D extends number = 5> = [D] extends [never] ? never : T extends object ? {
+    [K in keyof T]-?: K extends string | number ? `${K}` | Join<K, Key<T[K], Prev[D]>> : never;
+}[keyof T] : "";
+export {};

package/dist/deep/memo.d.ts

@@ -0,0 +1 @@
+export declare const memo: <F extends (...args: any[]) => any>(func: F) => F;

package/dist/deep/merge.d.ts

@@ -0,0 +1,2 @@
+import { type Partial } from '../deep/partial';
+export declare const merge: <T extends globalThis.Partial<Record<keyof T, unknown>>>(base: T, ...objects: Partial<T>[]) => T;

package/dist/deep/merge.spec.d.ts

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

package/dist/deep/partial.d.ts

@@ -0,0 +1,3 @@
+export type Partial<T> = T extends object ? {
+    [P in keyof T]?: Partial<T[P]>;
+} : T;

package/dist/destructor.d.ts

@@ -0,0 +1 @@
+export type Destructor = () => void;

package/dist/identity.d.ts

@@ -0,0 +1 @@
+export declare const isObject: <T extends Partial<Record<import('./record').Key, unknown>> = Partial<Record<import('./record').Key, unknown>>>(item?: unknown) => item is T;

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+export * from './telem';
+export * from './primitive';
+export * from './record';
+export * from './renderable';
+export * from './optional';
+export * from './identity';
+export * from './runtime';
+export * from './deep';
+export * from './debounce';
+export * from './clamp';
+export * from './compare';
+export * from './runtime';
+export * from './unique';
+export * from './kv';
+export * from './spatial';
+export * from './url';
+export * from './toArray';
+export * from './case';
+export * from './search';
+export * from './destructor';
+export * from './worker/worker';
+export * from './transform';
+export * from './binary';
+export * from './observe';
+export * from './change';

package/dist/join.d.ts

@@ -0,0 +1 @@
+export type Join<K, P> = K extends string | number ? P extends string | number ? `${K}${"" extends P ? "" : "."}${P}` : never : never;

package/dist/kv/index.d.ts

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

package/dist/kv/types.d.ts

@@ -0,0 +1,32 @@
+export interface KV<K = string, V = string, WK = K, WV = V, D = K> extends Reader<K, V>, Writer<WK, WV>, Deleter<D> {
+}
+export interface Reader<K = string, V = string> {
+    /** @returns the value for a given key, or null if the key is not present. */
+    get: (key: K) => V | null;
+}
+export interface Writer<K = string, V = string> {
+    /** Sets a key-value pair in the store. */
+    set: (key: K, value: V) => void;
+}
+export interface Deleter<K = string> {
+    /** Deletes a key-value pair from the store. */
+    delete: (key: K) => void;
+}
+/** A read-writable key-value store. */
+export interface Async<K = string, V = string, WK = K, WV = V, D = K> extends AsyncReader<K, V>, AsyncWriter<WK, WV>, AsyncDeleter<D> {
+}
+/** A readable key-value store. */
+export interface AsyncReader<K = string, V = string> {
+    /** Get the value for a given key. */
+    get: (key: K) => Promise<V | null>;
+}
+/** A writable key-value store. */
+export interface AsyncWriter<K = string, V = string> {
+    /** Sets a key-value pair in the store. The value must be serializable. */
+    set: (key: K, value: V) => Promise<void>;
+}
+/** A key-value store that can delete key-value pairs. */
+export interface AsyncDeleter<K = string> {
+    /** Deletes a key-value pair from the store. */
+    delete: (key: K) => Promise<void>;
+}

package/dist/mock/MockGLBufferController.d.ts

@@ -0,0 +1,20 @@
+import { Mock } from "vitest";
+import { GLBufferController } from '../telem/gl';
+export declare class MockGLBufferController implements GLBufferController {
+    ARRAY_BUFFER: number;
+    STATIC_DRAW: number;
+    DYNAMIC_DRAW: number;
+    targets: Record<number, number>;
+    counter: number;
+    buffers: Record<number, ArrayBuffer>;
+    createBufferMock: Mock<[], WebGLBuffer | null>;
+    bufferDataMock: Mock<[number, ArrayBufferLike | number, number]>;
+    bufferSubDataMock: Mock<[number, number, ArrayBufferLike]>;
+    bindBufferMock: Mock<[number, WebGLBuffer | null]>;
+    deleteBufferMock: Mock<[WebGLBuffer | null]>;
+    deleteBuffer(buffer: WebGLBuffer | null): void;
+    createBuffer(): WebGLBuffer | null;
+    bufferData(target: number, dataOrSize: ArrayBufferLike | number, usage: number): void;
+    bindBuffer(target: number, buffer: WebGLBuffer | null): void;
+    bufferSubData(target: number, offset: number, data: ArrayBufferLike): void;
+}

package/dist/mock/index.d.ts

@@ -0,0 +1 @@
+export * from '../mock/MockGLBufferController';

package/dist/observe/index.d.ts

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

package/dist/observe/observe.d.ts

@@ -0,0 +1,11 @@
+import { type Destructor } from '../destructor';
+export type Handler<T> = (value: T) => void;
+export interface Observable<T> {
+    onChange: (handler: Handler<T>) => Destructor;
+}
+export declare class Observer<T> implements Observable<T> {
+    private readonly handlers;
+    constructor();
+    onChange(handler: Handler<T>): Destructor;
+    notify(value: T): void;
+}

package/dist/optional.d.ts

@@ -0,0 +1 @@
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

package/dist/primitive.d.ts

@@ -0,0 +1,8 @@
+import { type Key } from './record';
+export type Primitive = string | number | bigint | boolean | Stringer | null | undefined;
+export interface Stringer {
+    toString: () => string;
+}
+export declare const isStringer: (value: unknown) => boolean;
+export type PrimitiveRecord = Record<Key, Primitive>;
+export declare const primitiveIsZero: (value: Primitive) => boolean;

package/dist/record.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { type RenderableValue } from './renderable';
+export type Key = string | number | symbol;
+export type KeyedRecord<K extends Key = Key, E extends Record<string, unknown> = Record<string, unknown>> = {
+    key: K;
+} & Partial<Record<keyof E, unknown>>;
+export type UnknownRecord<E extends Record<Key, unknown> = Record<Key, unknown>> = Partial<Record<keyof E, unknown>>;
+export type RenderableRecord<E extends Record<string, RenderableValue> = Record<string, RenderableValue>> = E;
+export type KeyedRenderableRecord<K extends Key = Key, E extends Record<string, RenderableValue> = Record<string, RenderableValue>> = KeyedRecord<K, E> & Omit<RenderableRecord<E>, "key">;
+export declare const unknownRecordZ: z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+export type Entries<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+export declare const getEntries: <T extends Record<Key, unknown>>(obj: T) => Entries<T>;

package/dist/renderable.d.ts

@@ -0,0 +1,4 @@
+import { type Stringer } from './primitive';
+export type PureRenderableValue = string | number | undefined;
+export type RenderableValue = PureRenderableValue | Stringer;
+export declare const convertRenderV: (value: RenderableValue) => string | number | undefined;

package/dist/runtime/detect.d.ts

@@ -0,0 +1,9 @@
+/** JavaScript runtime environments. */
+export type Runtime = "browser" | "node" | "webworker";
+/**
+ * Does best effort detection of the runtime environment.
+ *
+ * @returns The runtime environment.
+ */
+export declare const detect: () => Runtime;
+export declare const RUNTIME: Runtime;

package/dist/runtime/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../runtime/detect';
+export * from '../runtime/os';

package/dist/runtime/index.d.ts

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

package/dist/runtime/os.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const OPERATING_SYSTEMS: readonly ["MacOS", "Windows", "Linux", "Docker"];
+export declare const osZ: z.ZodEnum<["MacOS", "Windows", "Linux", "Docker"]>;
+export type OS = (typeof OPERATING_SYSTEMS)[number];
+export interface GetOSProps {
+    force?: OS;
+    default?: OS;
+}
+export declare const getOS: (props?: GetOSProps) => OS | undefined;

package/dist/search.d.ts

@@ -0,0 +1,15 @@
+import { type CompareF } from './compare/compare';
+import { type Key, type KeyedRecord } from './record';
+export declare const Search: {
+    binary: <T>(arr: T[], target: T, compare: CompareF<T>) => number;
+};
+export interface TermSearcher<T, K extends Key, E extends KeyedRecord<K, E>> {
+    search: (term: T) => E[];
+    retrieve: (keys: K[]) => E[];
+    page: (offset: number, limit: number) => E[];
+}
+export interface AsyncTermSearcher<T, K extends Key, E extends KeyedRecord<K, E>> {
+    search: (term: T) => Promise<E[]>;
+    retrieve: (keys: K[]) => Promise<E[]>;
+    page: (offset: number, limit: number) => Promise<E[]>;
+}

package/dist/spatial/base.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+export declare const numberCouple: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+export type NumberCouple = z.infer<typeof numberCouple>;
+export declare const dimensions: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    width: number;
+    height: number;
+}, {
+    width: number;
+    height: number;
+}>;
+export type Dimensions = z.infer<typeof dimensions>;
+export declare const signedDimensions: z.ZodObject<{
+    signedWidth: z.ZodNumber;
+    signedHeight: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    signedWidth: number;
+    signedHeight: number;
+}, {
+    signedWidth: number;
+    signedHeight: number;
+}>;
+export declare const DIMENSIONS: readonly ["width", "height"];
+export declare const dimension: z.ZodEnum<["width", "height"]>;
+export type Dimension = (typeof DIMENSIONS)[number];
+export declare const ALIGNMENTS: readonly ["start", "center", "end"];
+export declare const SIGNED_DIMENSIONS: readonly ["signedWidth", "signedHeight"];
+export declare const signedDimension: z.ZodEnum<["signedWidth", "signedHeight"]>;
+export type SignedDimension = (typeof SIGNED_DIMENSIONS)[number];
+export declare const xy: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}>;
+export type XY = z.infer<typeof xy>;
+export declare const clientXY: z.ZodObject<{
+    clientX: z.ZodNumber;
+    clientY: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    clientX: number;
+    clientY: number;
+}, {
+    clientX: number;
+    clientY: number;
+}>;
+export type ClientXY = z.infer<typeof clientXY>;
+export declare const DIRECTIONS: readonly ["x", "y"];
+export declare const direction: z.ZodEnum<["x", "y"]>;
+export type Direction = z.infer<typeof direction>;
+export declare const OUTER_LOCATIONS: readonly ["top", "right", "bottom", "left"];
+export declare const outerLocation: z.ZodEnum<["top", "right", "bottom", "left"]>;
+export type OuterLocation = (typeof OUTER_LOCATIONS)[number];
+export declare const X_LOCATIONS: readonly ["left", "right"];
+export declare const xLocation: z.ZodEnum<["left", "right"]>;
+export type XLocation = (typeof X_LOCATIONS)[number];
+export declare const Y_LOCATIONS: readonly ["top", "bottom"];
+export declare const yLocation: z.ZodEnum<["top", "bottom"]>;
+export type YLocation = (typeof Y_LOCATIONS)[number];
+export declare const CENTER_LOCATIONS: readonly ["center"];
+export declare const centerlocation: z.ZodEnum<["center"]>;
+export type CenterLocation = (typeof CENTER_LOCATIONS)[number];
+export declare const LOCATIONS: readonly ["top", "right", "bottom", "left", "center"];
+export declare const location: z.ZodEnum<["top", "right", "bottom", "left", "center"]>;
+export type Location = z.infer<typeof location>;
+export declare const alignment: z.ZodEnum<["start", "center", "end"]>;
+export type Alignment = (typeof ALIGNMENTS)[number];
+export declare const ORDERS: readonly ["first", "last"];
+export declare const order: z.ZodEnum<["first", "last"]>;
+export type Order = (typeof ORDERS)[number];
+export declare const bounds: z.ZodObject<{
+    lower: z.ZodNumber;
+    upper: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    lower: number;
+    upper: number;
+}, {
+    lower: number;
+    upper: number;
+}>;
+export type Bounds = z.infer<typeof bounds>;
+export declare const crudeBounds: z.ZodUnion<[z.ZodObject<{
+    lower: z.ZodNumber;
+    upper: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    lower: number;
+    upper: number;
+}, {
+    lower: number;
+    upper: number;
+}>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+export type CrudeBounds = z.infer<typeof crudeBounds>;
+export declare const crudeDirection: z.ZodUnion<[z.ZodEnum<["x", "y"]>, z.ZodEnum<["top", "right", "bottom", "left", "center"]>]>;
+export type CrudeDirection = z.infer<typeof crudeDirection>;
+export declare const crudeLocation: z.ZodUnion<[z.ZodEnum<["x", "y"]>, z.ZodEnum<["top", "right", "bottom", "left", "center"]>, z.ZodType<String, z.ZodTypeDef, String>]>;
+export type CrudeLocation = z.infer<typeof crudeLocation>;