spacetimedb 0.0.2 → 0.0.3

package/dist/server/type_builders.d.ts

@@ -0,0 +1,656 @@
+import { AlgebraicType, ConnectionId, Identity, ScheduleAt, TimeDuration, Timestamp, type AlgebraicTypeVariants } from '..';
+import type { Set } from './type_util';
+/**
+ * Helper type to extract the TypeScript type from a TypeBuilder
+ */
+export type InferTypeOfTypeBuilder<T> = T extends TypeBuilder<infer U, any> ? U : never;
+/**
+ * Helper type to extract the TypeScript type from a TypeBuilder
+ */
+export type Infer<T> = InferTypeOfTypeBuilder<T>;
+/**
+ * Helper type to extract the type of a row from an object.
+ */
+export type InferTypeOfRow<T> = T extends Record<string, ColumnBuilder<any, any, any> | TypeBuilder<any, any>> ? {
+    [K in keyof T]: T[K] extends ColumnBuilder<infer V, any, any> ? V : T[K] extends TypeBuilder<infer V, any> ? V : never;
+} : never;
+/**
+ * Type which represents a valid argument to the ProductColumnBuilder
+ */
+type ElementsObj = Record<string, TypeBuilder<any, any>>;
+/**
+ * Type which converts the elements of ElementsObj to a ProductType elements array
+ */
+type ElementsArrayFromElementsObj<Obj extends ElementsObj> = {
+    name: keyof Obj & string;
+    algebraicType: Obj[keyof Obj & string]['spacetimeType'];
+}[];
+/**
+ * A type which converts the elements of ElementsObj to a TypeScript object type.
+ * It works by `Infer`ing the types of the column builders which are the values of
+ * the keys in the object passed in.
+ *
+ * e.g. { a: I32TypeBuilder, b: StringBuilder } -> { a: number, b: string }
+ */
+type TypeScriptTypeFromElementsObj<Elements extends ElementsObj> = {
+    [K in keyof Elements]: InferTypeOfTypeBuilder<Elements[K]>;
+};
+type VariantsObj = Record<string, TypeBuilder<any, any>>;
+/**
+ * A type which converts the elements of ElementsObj to a TypeScript object type.
+ * It works by `Infer`ing the types of the column builders which are the values of
+ * the keys in the object passed in.
+ *
+ * e.g. { A: I32TypeBuilder, B: StringBuilder } -> { tag: "A", value: number } | { tag: "B", value: string }
+ */
+type TypeScriptTypeFromVariantsObj<Variants extends VariantsObj> = {
+    [K in keyof Variants]: {
+        tag: K;
+        value: InferTypeOfTypeBuilder<Variants[K]>;
+    };
+}[keyof Variants];
+/**
+ * Type which converts the elements of VariantsObj to a SumType variants array
+ */
+type VariantsArrayFromVariantsObj<Obj extends VariantsObj> = {
+    name: keyof Obj & string;
+    algebraicType: Obj[keyof Obj & string]['spacetimeType'];
+}[];
+/**
+ * A generic type builder that captures both the TypeScript type
+ * and the corresponding `AlgebraicType`.
+ */
+export declare class TypeBuilder<Type, SpacetimeType extends AlgebraicType> {
+    /**
+     * The TypeScript phantom type. This is not stored at runtime,
+     * but is visible to the compiler
+     */
+    readonly type: Type;
+    /**
+     * TypeScript phantom type representing the type of the particular
+     * AlgebraicType stored in {@link algebraicType}.
+     */
+    readonly spacetimeType: SpacetimeType;
+    /**
+     * The SpacetimeDB algebraic type (run‑time value). In addition to storing
+     * the runtime representation of the `AlgebraicType`, it also captures
+     * the TypeScript type information of the `AlgebraicType`. That is to say
+     * the value is not merely an `AlgebraicType`, but is constructed to be
+     * the corresponding concrete `AlgebraicType` for the TypeScript type `Type`.
+     *
+     * e.g. `string` corresponds to `AlgebraicType.String`
+     */
+    readonly algebraicType: AlgebraicType;
+    constructor(algebraicType: AlgebraicType);
+}
+/**
+ * Interface for types that can be converted into a column builder with primary key metadata.
+ *
+ * Implementing this interface allows a type to be marked as the primary key of a table column
+ * in a type-safe manner. The `primaryKey()` method returns a new `ColumnBuilder` instance
+ * with the metadata updated to indicate that the column is a primary key.
+ *
+ * @typeParam Type - The TypeScript type of the column's value.
+ * @typeParam SpacetimeType - The corresponding SpacetimeDB algebraic type.
+ * @typeParam M - The metadata type for the column, defaulting to `DefaultMetadata`.
+ *
+ * @remarks
+ * - This interface is typically implemented by type builders for primitive and complex types.
+ * - The returned `ColumnBuilder` will have its metadata extended with `{ isPrimaryKey: true }`.
+ * - Marking a column as a primary key is mutually exclusive with certain other metadata flags,
+ *   such as `isAutoIncrement` or `isUnique`, depending on the database schema rules.
+ */
+interface PrimaryKeyable<Type, SpacetimeType extends AlgebraicType, M extends ColumnMetadata = DefaultMetadata> {
+    /**
+     * Specify this column as primary key
+     */
+    primaryKey(): ColumnBuilder<Type, SpacetimeType, Set<M, 'isPrimaryKey', true>>;
+}
+/**
+ * Interface for types that can be converted into a column builder with unique metadata.
+ *
+ * Implementing this interface allows a type to be marked as unique in a table column
+ * in a type-safe manner. The `unique()` method returns a new `ColumnBuilder` instance
+ * with the metadata updated to indicate that the column is unique.
+ *
+ * @typeParam Type - The TypeScript type of the column's value.
+ * @typeParam SpacetimeType - The corresponding SpacetimeDB algebraic type.
+ * @typeParam M - The metadata type for the column, defaulting to `DefaultMetadata`.
+ *
+ * @remarks
+ * - This interface is typically implemented by type builders for primitive and complex types.
+ * - The returned `ColumnBuilder` will have its metadata extended with `{ isUnique: true }`.
+ * - Marking a column as unique is mutually exclusive with certain other metadata flags,
+ *   such as `isAutoIncrement` or `isPrimaryKey`, depending on the database schema rules.
+ */
+interface Uniqueable<Type, SpacetimeType extends AlgebraicType, M extends ColumnMetadata = DefaultMetadata> {
+    /**
+     * Specify this column as unique
+     */
+    unique(): ColumnBuilder<Type, SpacetimeType, Set<M, 'isUnique', true>>;
+}
+/**
+ * Interface for types that can be converted into a column builder with index metadata.
+ *
+ * Implementing this interface allows a type to be indexed in a table column
+ * in a type-safe manner. The `index()` method returns a new `ColumnBuilder` instance
+ * with the metadata updated to indicate the index type.
+ *
+ * @typeParam Type - The TypeScript type of the column's value.
+ * @typeParam SpacetimeType - The corresponding SpacetimeDB algebraic type.
+ * @typeParam M - The metadata type for the column, defaulting to `DefaultMetadata`.
+ *
+ * @remarks
+ * - This interface is typically implemented by type builders for primitive and complex types.
+ * - The returned `ColumnBuilder` will have its metadata extended with `{ indexType: N }`.
+ * - Indexing a column may have implications for performance and query optimization.
+ */
+interface Indexable<Type, SpacetimeType extends AlgebraicType, M extends ColumnMetadata = DefaultMetadata> {
+    /**
+     * Specify the index type for this column
+     * @param algorithm The index algorithm to use
+     */
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): ColumnBuilder<Type, SpacetimeType, Set<M, 'indexType', N>>;
+}
+/**
+ * Interface for types that can be converted into a column builder with auto-increment metadata.
+ *
+ * Implementing this interface allows a type to be marked as auto-incrementing in a table column
+ * in a type-safe manner. The `autoInc()` method returns a new `ColumnBuilder` instance
+ * with the metadata updated to indicate that the column is auto-incrementing.
+ *
+ * @typeParam Type - The TypeScript type of the column's value.
+ * @typeParam SpacetimeType - The corresponding SpacetimeDB algebraic type.
+ * @typeParam M - The metadata type for the column, defaulting to `DefaultMetadata`.
+ *
+ * @remarks
+ * - This interface is typically implemented by type builders for primitive and complex types.
+ * - The returned `ColumnBuilder` will have its metadata extended with `{ isAutoIncrement: true }`.
+ * - Marking a column as auto-incrementing is mutually exclusive with certain other metadata flags,
+ *   such as `isUnique` or `isPrimaryKey`, depending on the database schema rules.
+ */
+interface AutoIncrementable<Type, SpacetimeType extends AlgebraicType, M extends ColumnMetadata = DefaultMetadata> {
+    /**
+     * Specify this column as auto-incrementing
+     */
+    autoInc(): ColumnBuilder<Type, SpacetimeType, Set<M, 'isAutoIncrement', true>>;
+}
+export declare class U8Builder extends TypeBuilder<number, AlgebraicTypeVariants.U8> implements Indexable<number, AlgebraicTypeVariants.U8>, Uniqueable<number, AlgebraicTypeVariants.U8>, PrimaryKeyable<number, AlgebraicTypeVariants.U8>, AutoIncrementable<number, AlgebraicTypeVariants.U8> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U8ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): U8ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): U8ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): U8ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class U16Builder extends TypeBuilder<number, AlgebraicTypeVariants.U16> implements Indexable<number, AlgebraicTypeVariants.U16>, Uniqueable<number, AlgebraicTypeVariants.U16>, PrimaryKeyable<number, AlgebraicTypeVariants.U16>, AutoIncrementable<number, AlgebraicTypeVariants.U16> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U16ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): U16ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): U16ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): U16ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class U32Builder extends TypeBuilder<number, AlgebraicTypeVariants.U32> implements Indexable<number, AlgebraicTypeVariants.U32>, Uniqueable<number, AlgebraicTypeVariants.U32>, PrimaryKeyable<number, AlgebraicTypeVariants.U32>, AutoIncrementable<number, AlgebraicTypeVariants.U32> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U32ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): U32ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): U32ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): U32ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class U64Builder extends TypeBuilder<bigint, AlgebraicTypeVariants.U64> implements Indexable<bigint, AlgebraicTypeVariants.U64>, Uniqueable<bigint, AlgebraicTypeVariants.U64>, PrimaryKeyable<bigint, AlgebraicTypeVariants.U64>, AutoIncrementable<bigint, AlgebraicTypeVariants.U64> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U64ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): U64ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): U64ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): U64ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class U128Builder extends TypeBuilder<bigint, AlgebraicTypeVariants.U128> implements Indexable<bigint, AlgebraicTypeVariants.U128>, Uniqueable<bigint, AlgebraicTypeVariants.U128>, PrimaryKeyable<bigint, AlgebraicTypeVariants.U128>, AutoIncrementable<bigint, AlgebraicTypeVariants.U128> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U128ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): U128ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): U128ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): U128ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class U256Builder extends TypeBuilder<bigint, AlgebraicTypeVariants.U256> implements Indexable<bigint, AlgebraicTypeVariants.U256>, Uniqueable<bigint, AlgebraicTypeVariants.U256>, PrimaryKeyable<bigint, AlgebraicTypeVariants.U256>, AutoIncrementable<bigint, AlgebraicTypeVariants.U256> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U256ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): U256ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): U256ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): U256ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class I8Builder extends TypeBuilder<number, AlgebraicTypeVariants.I8> implements Indexable<number, AlgebraicTypeVariants.I8>, Uniqueable<number, AlgebraicTypeVariants.I8>, PrimaryKeyable<number, AlgebraicTypeVariants.I8>, AutoIncrementable<number, AlgebraicTypeVariants.I8> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I8ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): I8ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): I8ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): I8ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class I16Builder extends TypeBuilder<number, AlgebraicTypeVariants.I16> implements Indexable<number, AlgebraicTypeVariants.I16>, Uniqueable<number, AlgebraicTypeVariants.I16>, PrimaryKeyable<number, AlgebraicTypeVariants.I16>, AutoIncrementable<number, AlgebraicTypeVariants.I16> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I16ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): I16ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): I16ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): I16ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class I32Builder extends TypeBuilder<number, AlgebraicTypeVariants.I32> implements Indexable<number, AlgebraicTypeVariants.I32>, Uniqueable<number, AlgebraicTypeVariants.I32>, PrimaryKeyable<number, AlgebraicTypeVariants.I32>, AutoIncrementable<number, AlgebraicTypeVariants.I32> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I32ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): I32ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): I32ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): I32ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class I64Builder extends TypeBuilder<bigint, AlgebraicTypeVariants.I64> implements Indexable<bigint, AlgebraicTypeVariants.I64>, Uniqueable<bigint, AlgebraicTypeVariants.I64>, PrimaryKeyable<bigint, AlgebraicTypeVariants.I64>, AutoIncrementable<bigint, AlgebraicTypeVariants.I64> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I64ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): I64ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): I64ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): I64ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class I128Builder extends TypeBuilder<bigint, AlgebraicTypeVariants.I128> implements Indexable<bigint, AlgebraicTypeVariants.I128>, Uniqueable<bigint, AlgebraicTypeVariants.I128>, PrimaryKeyable<bigint, AlgebraicTypeVariants.I128>, AutoIncrementable<bigint, AlgebraicTypeVariants.I128> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I128ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): I128ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): I128ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): I128ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class I256Builder extends TypeBuilder<bigint, AlgebraicTypeVariants.I256> implements Indexable<bigint, AlgebraicTypeVariants.I256>, Uniqueable<bigint, AlgebraicTypeVariants.I256>, PrimaryKeyable<bigint, AlgebraicTypeVariants.I256>, AutoIncrementable<bigint, AlgebraicTypeVariants.I256> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I256ColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): I256ColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): I256ColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+    autoInc(): I256ColumnBuilder<Set<DefaultMetadata, 'isAutoIncrement', true>>;
+}
+export declare class F32Builder extends TypeBuilder<number, AlgebraicTypeVariants.F32> {
+    constructor();
+}
+export declare class F64Builder extends TypeBuilder<number, AlgebraicTypeVariants.F64> {
+    constructor();
+}
+export declare class BoolBuilder extends TypeBuilder<boolean, AlgebraicTypeVariants.Bool> implements Indexable<boolean, AlgebraicTypeVariants.Bool>, Uniqueable<boolean, AlgebraicTypeVariants.Bool>, PrimaryKeyable<boolean, AlgebraicTypeVariants.Bool> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): BoolColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): BoolColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): BoolColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+}
+export declare class StringBuilder extends TypeBuilder<string, AlgebraicTypeVariants.String> implements Indexable<string, AlgebraicTypeVariants.String>, Uniqueable<string, AlgebraicTypeVariants.String>, PrimaryKeyable<string, AlgebraicTypeVariants.String> {
+    constructor();
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): StringColumnBuilder<Set<DefaultMetadata, 'indexType', N>>;
+    unique(): StringColumnBuilder<Set<DefaultMetadata, 'isUnique', true>>;
+    primaryKey(): StringColumnBuilder<Set<DefaultMetadata, 'isPrimaryKey', true>>;
+}
+export declare class ArrayBuilder<Element extends TypeBuilder<any, any>> extends TypeBuilder<Array<Element['type']>, {
+    tag: 'Array';
+    value: Element['spacetimeType'];
+}> {
+    /**
+     * The phantom element type of the array for TypeScript
+     */
+    readonly element: Element;
+    constructor(element: Element);
+}
+export declare class ProductBuilder<Elements extends ElementsObj> extends TypeBuilder<TypeScriptTypeFromElementsObj<Elements>, {
+    tag: 'Product';
+    value: {
+        elements: ElementsArrayFromElementsObj<Elements>;
+    };
+}> {
+    /**
+     * The phantom element types of the product for TypeScript
+     */
+    readonly elements: Elements;
+    constructor(elements: Elements);
+}
+export declare class SumBuilder<Variants extends VariantsObj> extends TypeBuilder<TypeScriptTypeFromVariantsObj<Variants>, {
+    tag: 'Sum';
+    value: {
+        variants: VariantsArrayFromVariantsObj<Variants>;
+    };
+}> {
+    /**
+     * The phantom variant types of the sum for TypeScript
+     */
+    readonly variants: Variants;
+    constructor(variants: Variants);
+}
+/**
+ * The type of index types that can be applied to a column.
+ * `undefined` is the default
+ */
+type IndexTypes = 'btree' | 'hash' | undefined;
+/**
+ * Metadata describing column constraints and index type
+ */
+export type ColumnMetadata = {
+    isPrimaryKey?: true;
+    isUnique?: true;
+    isAutoIncrement?: true;
+    isScheduleAt?: true;
+    indexType?: IndexTypes;
+};
+/**
+ * Default metadata state type for a newly created column
+ */
+type DefaultMetadata = object;
+/**
+ * A column builder allows you to incrementally specify constraints
+ * and metadata for a column in a type-safe way.
+ *
+ * It carries both a phantom TypeScript type (the `Type`) and
+ * runtime algebraic type information.
+ */
+export declare class ColumnBuilder<Type, SpacetimeType extends AlgebraicType, M extends ColumnMetadata = DefaultMetadata> {
+    /**
+     * The TypeScript phantom type. This is not stored at runtime,
+     * but is visible to the compiler
+     */
+    readonly columnMetadataType: M;
+    typeBuilder: TypeBuilder<Type, SpacetimeType>;
+    columnMetadata: ColumnMetadata;
+    constructor(typeBuilder: TypeBuilder<Type, SpacetimeType>, metadata?: ColumnMetadata);
+}
+export declare class U8ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<number, AlgebraicTypeVariants.U8, M> implements Indexable<number, AlgebraicTypeVariants.U8>, Uniqueable<number, AlgebraicTypeVariants.U8>, PrimaryKeyable<number, AlgebraicTypeVariants.U8>, AutoIncrementable<number, AlgebraicTypeVariants.U8> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U8ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): U8ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): U8ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): U8ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class U16ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<number, AlgebraicTypeVariants.U16, M> implements Indexable<number, AlgebraicTypeVariants.U16>, Uniqueable<number, AlgebraicTypeVariants.U16>, PrimaryKeyable<number, AlgebraicTypeVariants.U16>, AutoIncrementable<number, AlgebraicTypeVariants.U16> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U16ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): U16ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): U16ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): U16ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class U32ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<number, AlgebraicTypeVariants.U32, M> implements Indexable<number, AlgebraicTypeVariants.U32>, Uniqueable<number, AlgebraicTypeVariants.U32>, PrimaryKeyable<number, AlgebraicTypeVariants.U32>, AutoIncrementable<number, AlgebraicTypeVariants.U32> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U32ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): U32ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): U32ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): U32ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class U64ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<bigint, AlgebraicTypeVariants.U64, M> implements Indexable<bigint, AlgebraicTypeVariants.U64>, Uniqueable<bigint, AlgebraicTypeVariants.U64>, PrimaryKeyable<bigint, AlgebraicTypeVariants.U64>, AutoIncrementable<bigint, AlgebraicTypeVariants.U64> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U64ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): U64ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): U64ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): U64ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class U128ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<bigint, AlgebraicTypeVariants.U128, M> implements Indexable<bigint, AlgebraicTypeVariants.U128>, Uniqueable<bigint, AlgebraicTypeVariants.U128>, PrimaryKeyable<bigint, AlgebraicTypeVariants.U128>, AutoIncrementable<bigint, AlgebraicTypeVariants.U128> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U128ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): U128ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): U128ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): U128ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class U256ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<bigint, AlgebraicTypeVariants.U256, M> implements Indexable<bigint, AlgebraicTypeVariants.U256>, Uniqueable<bigint, AlgebraicTypeVariants.U256>, PrimaryKeyable<bigint, AlgebraicTypeVariants.U256>, AutoIncrementable<bigint, AlgebraicTypeVariants.U256> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): U256ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): U256ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): U256ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): U256ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class I8ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<number, AlgebraicTypeVariants.I8, M> implements Indexable<number, AlgebraicTypeVariants.I8>, Uniqueable<number, AlgebraicTypeVariants.I8>, PrimaryKeyable<number, AlgebraicTypeVariants.I8>, AutoIncrementable<number, AlgebraicTypeVariants.I8> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I8ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): I8ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): I8ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): I8ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class I16ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<number, AlgebraicTypeVariants.I16, M> implements Indexable<number, AlgebraicTypeVariants.I16>, Uniqueable<number, AlgebraicTypeVariants.I16>, PrimaryKeyable<number, AlgebraicTypeVariants.I16>, AutoIncrementable<number, AlgebraicTypeVariants.I16> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I16ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): I16ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): I16ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): I16ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class I32ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<number, AlgebraicTypeVariants.I32, M> implements Indexable<number, AlgebraicTypeVariants.I32>, Uniqueable<number, AlgebraicTypeVariants.I32>, PrimaryKeyable<number, AlgebraicTypeVariants.I32>, AutoIncrementable<number, AlgebraicTypeVariants.I32> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I32ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): I32ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): I32ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): I32ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class I64ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<bigint, AlgebraicTypeVariants.I64, M> implements Indexable<bigint, AlgebraicTypeVariants.I64>, Uniqueable<bigint, AlgebraicTypeVariants.I64>, PrimaryKeyable<bigint, AlgebraicTypeVariants.I64>, AutoIncrementable<bigint, AlgebraicTypeVariants.I64> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I64ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): I64ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): I64ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): I64ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class I128ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<bigint, AlgebraicTypeVariants.I128, M> implements Indexable<bigint, AlgebraicTypeVariants.I128>, Uniqueable<bigint, AlgebraicTypeVariants.I128>, PrimaryKeyable<bigint, AlgebraicTypeVariants.I128>, AutoIncrementable<bigint, AlgebraicTypeVariants.I128> {
+    index<M extends ColumnMetadata = DefaultMetadata, N extends IndexTypes = 'btree'>(algorithm?: N): I128ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): I128ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): I128ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): I128ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class I256ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<bigint, AlgebraicTypeVariants.I256, M> implements Indexable<bigint, AlgebraicTypeVariants.I256>, Uniqueable<bigint, AlgebraicTypeVariants.I256>, PrimaryKeyable<bigint, AlgebraicTypeVariants.I256>, AutoIncrementable<bigint, AlgebraicTypeVariants.I256> {
+    index<N extends IndexTypes = 'btree'>(algorithm?: N): I256ColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): I256ColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): I256ColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+    autoInc(): I256ColumnBuilder<Set<M, 'isAutoIncrement', true>>;
+}
+export declare class F32ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<number, AlgebraicTypeVariants.F32, M> {
+}
+export declare class F64ColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<number, AlgebraicTypeVariants.F64, M> {
+}
+export declare class BoolColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<boolean, AlgebraicTypeVariants.Bool, M> implements Indexable<boolean, AlgebraicTypeVariants.Bool>, Uniqueable<boolean, AlgebraicTypeVariants.Bool>, PrimaryKeyable<boolean, AlgebraicTypeVariants.Bool> {
+    index<M extends ColumnMetadata = DefaultMetadata, N extends IndexTypes = 'btree'>(algorithm?: N): BoolColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): BoolColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): BoolColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+}
+export declare class StringColumnBuilder<M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<string, AlgebraicTypeVariants.String, M> implements Indexable<string, AlgebraicTypeVariants.String>, Uniqueable<string, AlgebraicTypeVariants.String>, PrimaryKeyable<string, AlgebraicTypeVariants.String> {
+    index<M extends ColumnMetadata = DefaultMetadata, N extends IndexTypes = 'btree'>(algorithm?: N): StringColumnBuilder<Set<M, 'indexType', N>>;
+    unique(): StringColumnBuilder<Set<M, 'isUnique', true>>;
+    primaryKey(): StringColumnBuilder<Set<M, 'isPrimaryKey', true>>;
+}
+export declare class ArrayColumnBuilder<Element extends TypeBuilder<any, any>, M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<Array<Element['type']>, {
+    tag: 'Array';
+    value: Element['spacetimeType'];
+}, M> {
+}
+export declare class ProductColumnBuilder<Elements extends Array<{
+    name: string;
+    algebraicType: AlgebraicType;
+}>, M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<{
+    [K in Elements[number]['name']]: any;
+}, {
+    tag: 'Product';
+    value: {
+        elements: Elements;
+    };
+}, M> {
+}
+export declare class SumColumnBuilder<Variants extends Array<{
+    name: string;
+    algebraicType: AlgebraicType;
+}>, M extends ColumnMetadata = DefaultMetadata> extends ColumnBuilder<{
+    [K in Variants[number]['name']]: {
+        tag: K;
+        value: any;
+    };
+}[Variants[number]['name']], {
+    tag: 'Sum';
+    value: {
+        variants: Variants;
+    };
+}, M> {
+}
+/**
+ * A collection of factory functions for creating various SpacetimeDB algebraic types
+ * to be used in table definitions. Each function returns a corresponding builder
+ * for a specific type, such as `BoolBuilder`, `StringBuilder`, or `F64Builder`.
+ *
+ * These builders are used to define the schema of tables in SpacetimeDB, and each
+ * builder implements the {@link TypeBuilder} interface, allowing for type-safe
+ * schema construction in TypeScript.
+ *
+ * @remarks
+ * - Primitive types (e.g., `bool`, `string`, `number`) map to their respective TypeScript types.
+ * - Integer and floating-point types (e.g., `i8`, `u64`, `f32`) are represented as `number` or `bigint` in TypeScript.
+ * - Complex types such as `object`, `array`, and `enum` allow for nested and structured schemas.
+ * - The `scheduleAt` builder is a special column type for scheduling.
+ *
+ * @see {@link TypeBuilder}
+ */
+declare const t: {
+    /**
+     * Creates a new `Bool` {@link AlgebraicType} to be used in table definitions
+     * Represented as `boolean` in TypeScript.
+     * @returns A new {@link BoolBuilder} instance
+     */
+    readonly bool: () => BoolBuilder;
+    /**
+     * Creates a new `String` {@link AlgebraicType} to be used in table definitions
+     * Represented as `string` in TypeScript.
+     * @returns A new {@link StringBuilder} instance
+     */
+    readonly string: () => StringBuilder;
+    /**
+     * Creates a new `F64` {@link AlgebraicType} to be used in table definitions
+     * Represented as `number` in TypeScript.
+     * @returns A new {@link F64Builder} instance
+     */
+    readonly number: () => F64Builder;
+    /**
+     * Creates a new `I8` {@link AlgebraicType} to be used in table definitions
+     * Represented as `number` in TypeScript.
+     * @returns A new {@link I8Builder} instance
+     */
+    readonly i8: () => I8Builder;
+    /**
+     * Creates a new `U8` {@link AlgebraicType} to be used in table definitions
+     * Represented as `number` in TypeScript.
+     * @returns A new {@link U8Builder} instance
+     */
+    readonly u8: () => U8Builder;
+    /**
+     * Creates a new `I16` {@link AlgebraicType} to be used in table definitions
+     * Represented as `number` in TypeScript.
+     * @returns A new {@link I16Builder} instance
+     */
+    readonly i16: () => I16Builder;
+    /**
+     * Creates a new `U16` {@link AlgebraicType} to be used in table definitions
+     * Represented as `number` in TypeScript.
+     * @returns A new {@link U16Builder} instance
+     */
+    readonly u16: () => U16Builder;
+    /**
+     * Creates a new `I32` {@link AlgebraicType} to be used in table definitions
+     * Represented as `number` in TypeScript.
+     * @returns A new {@link I32Builder} instance
+     */
+    readonly i32: () => I32Builder;
+    /**
+     * Creates a new `U32` {@link AlgebraicType} to be used in table definitions
+     * Represented as `number` in TypeScript.
+     * @returns A new {@link U32Builder} instance
+     */
+    readonly u32: () => U32Builder;
+    /**
+     * Creates a new `I64` {@link AlgebraicType} to be used in table definitions
+     * Represented as `bigint` in TypeScript.
+     * @returns A new {@link I64Builder} instance
+     */
+    readonly i64: () => I64Builder;
+    /**
+     * Creates a new `U64` {@link AlgebraicType} to be used in table definitions
+     * Represented as `bigint` in TypeScript.
+     * @returns A new {@link U64Builder} instance
+     */
+    readonly u64: () => U64Builder;
+    /**
+     * Creates a new `I128` {@link AlgebraicType} to be used in table definitions
+     * Represented as `bigint` in TypeScript.
+     * @returns A new {@link I128Builder} instance
+     */
+    readonly i128: () => I128Builder;
+    /**
+     * Creates a new `U128` {@link AlgebraicType} to be used in table definitions
+     * Represented as `bigint` in TypeScript.
+     * @returns A new {@link U128Builder} instance
+     */
+    readonly u128: () => U128Builder;
+    /**
+     * Creates a new `I256` {@link AlgebraicType} to be used in table definitions
+     * Represented as `bigint` in TypeScript.
+     * @returns A new {@link I256Builder} instance
+     */
+    readonly i256: () => I256Builder;
+    /**
+     * Creates a new `U256` {@link AlgebraicType} to be used in table definitions
+     * Represented as `bigint` in TypeScript.
+     * @returns A new {@link U256Builder} instance
+     */
+    readonly u256: () => U256Builder;
+    /**
+     * Creates a new `F32` {@link AlgebraicType} to be used in table definitions
+     * Represented as `number` in TypeScript.
+     * @returns A new {@link F32Builder} instance
+     */
+    readonly f32: () => F32Builder;
+    /**
+     * Creates a new `F64` {@link AlgebraicType} to be used in table definitions
+     * Represented as `number` in TypeScript.
+     * @returns A new {@link F64Builder} instance
+     */
+    readonly f64: () => F64Builder;
+    /**
+     * Creates a new `Product` {@link AlgebraicType} to be used in table definitions. Product types in SpacetimeDB
+     * are essentially the same as objects in JavaScript/TypeScript.
+     * Properties of the object must also be {@link TypeBuilder}s.
+     * Represented as an object with specific properties in TypeScript.
+     * @param obj The object defining the properties of the type, whose property
+     * values must be {@link TypeBuilder}s.
+     * @returns A new {@link ProductBuilder} instance
+     */
+    readonly object: <Obj extends ElementsObj>(obj: Obj) => ProductBuilder<Obj>;
+    /**
+     * Creates a new `Array` {@link AlgebraicType} to be used in table definitions.
+     * Represented as an array in TypeScript.
+     * @param element The element type of the array, which must be a `TypeBuilder`.
+     * @returns A new {@link ArrayBuilder} instance
+     */
+    readonly array: <Element extends TypeBuilder<any, any>>(e: Element) => ArrayBuilder<Element>;
+    /**
+     * Creates a new `Sum` {@link AlgebraicType} to be used in table definitions. Sum types in SpacetimeDB
+     * are similar to enums or unions in languages like Rust or TypeScript respectively.
+     * Each variant of the enum must be a {@link TypeBuilder}.
+     * Represented as a union of string literals in TypeScript.
+     * @param obj The object defining the variants of the enum, whose variant
+     * types must be `TypeBuilder`s.
+     * @returns A new {@link SumBuilder} instance
+     */
+    readonly enum: <Obj extends VariantsObj>(obj: Obj) => SumBuilder<Obj>;
+    /**
+     * This is a special helper function for conveniently creating {@link ScheduleAt} type columns.
+     * @returns A new ColumnBuilder instance with the {@link ScheduleAt} type.
+     */
+    readonly scheduleAt: () => ColumnBuilder<ScheduleAt, ReturnType<typeof ScheduleAt.getAlgebraicType>, Omit<ColumnMetadata, "isScheduleAt"> & {
+        isScheduleAt: true;
+    }>;
+    /**
+     * This is a convenience method for creating a column with the {@link Identity} type.
+     * You can create a column of the same type by constructing an `object` with a single `__identity__` element.
+     * @returns A new {@link TypeBuilder} instance with the {@link Identity} type.
+     */
+    readonly identity: () => TypeBuilder<Identity, AlgebraicTypeVariants.Product & {
+        value: typeof Identity;
+    }>;
+    /**
+     * This is a convenience method for creating a column with the {@link ConnectionId} type.
+     * You can create a column of the same type by constructing an `object` with a single `__connection_id__` element.
+     * @returns A new {@link TypeBuilder} instance with the {@link ConnectionId} type.
+     */
+    readonly connectionId: () => TypeBuilder<string, AlgebraicTypeVariants.Product & {
+        value: typeof ConnectionId;
+    }>;
+    /**
+     * This is a convenience method for creating a column with the {@link Timestamp} type.
+     * You can create a column of the same type by constructing an `object` with a single `__timestamp_micros_since_unix_epoch__` element.
+     * @returns A new {@link TypeBuilder} instance with the {@link Timestamp} type.
+     */
+    readonly timestamp: () => TypeBuilder<Timestamp, AlgebraicTypeVariants.Product & {
+        value: typeof Timestamp;
+    }>;
+    /**
+     * This is a convenience method for creating a column with the {@link TimeDuration} type.
+     * You can create a column of the same type by constructing an `object` with a single `__time_duration_micros__` element.
+     * @returns A new {@link TypeBuilder} instance with the {@link TimeDuration} type.
+     */
+    readonly timeDuration: () => TypeBuilder<TimeDuration, AlgebraicTypeVariants.Product & {
+        value: typeof TimeDuration;
+    }>;
+};
+export default t;
+//# sourceMappingURL=type_builders.d.ts.map