@livestore/common 0.3.2-dev.5 → 0.3.2-dev.6

package/dist/schema/EventDef.d.ts

@@ -1,123 +1,197 @@
-import type { SingleOrReadonlyArray } from '@livestore/utils';
-import { Schema } from '@livestore/utils/effect';
-import type { BindValues } from '../sql-queries/sql-queries.ts';
-import type { ParamsObject } from '../util.ts';
-import type { QueryBuilder } from './state/sqlite/query-builder/mod.ts';
+import type { Schema } from "@livestore/utils/effect";
+import type { SingleOrReadonlyArray } from "../../../utils/dist/mod.ts";
+import type { BindValues } from "../sql-queries/sql-queries.ts";
+import type { ParamsObject } from "../util.ts";
+import type { QueryBuilder } from "./state/sqlite/query-builder/mod.ts";
 export type EventDefMap = {
-    map: Map<string, EventDef.Any>;
+	map: Map<string, EventDef.Any>;
 };
 export type EventDefRecord = {
-    [name: string]: EventDef.Any;
+	[name: string]: EventDef.Any;
 };
-export type EventDef<TName extends string, TType, TEncoded = TType, TDerived extends boolean = false> = {
-    name: TName;
-    schema: Schema.Schema<TType, TEncoded>;
-    options: {
-        /**
-         * When set to true, the mutation won't be synced across clients but
-         */
-        clientOnly: boolean;
-        /** Warning: This feature is not fully implemented yet */
-        facts: FactsCallback<TType> | undefined;
-        derived: TDerived;
-    };
-    /** Helper function to construct a partial event */
-    (args: TType): {
-        name: TName;
-        args: TType;
-    };
-    /** Helper function to construct a partial encoded event */
-    encoded: (args: TEncoded) => {
-        name: TName;
-        args: TEncoded;
-    };
-    readonly Event: {
-        name: TName;
-        args: TType;
-    };
+export type EventDef<
+	TName extends string,
+	TType,
+	TEncoded = TType,
+	TDerived extends boolean = false,
+> = {
+	name: TName;
+	schema: Schema.Schema<TType, TEncoded>;
+	options: {
+		/**
+		 * When set to true, the mutation won't be synced across clients but
+		 */
+		clientOnly: boolean;
+		/** Warning: This feature is not fully implemented yet */
+		facts: FactsCallback<TType> | undefined;
+		derived: TDerived;
+	};
+	/** Helper function to construct a partial event */
+	(
+		args: TType,
+	): {
+		name: TName;
+		args: TType;
+	};
+	/** Helper function to construct a partial encoded event */
+	encoded: (args: TEncoded) => {
+		name: TName;
+		args: TEncoded;
+	};
+	readonly Event: {
+		name: TName;
+		args: TType;
+	};
 };
-export type FactsCallback<TTo> = (args: TTo, currentFacts: EventDefFacts) => {
-    modify: {
-        set: Iterable<EventDefFactInput>;
-        unset: Iterable<EventDefFactInput>;
-    };
-    require: Iterable<EventDefFactInput>;
+export type FactsCallback<TTo> = (
+	args: TTo,
+	currentFacts: EventDefFacts,
+) => {
+	modify: {
+		set: Iterable<EventDefFactInput>;
+		unset: Iterable<EventDefFactInput>;
+	};
+	require: Iterable<EventDefFactInput>;
 };
 export declare namespace EventDef {
-    type Any = EventDef<string, any, any, boolean>;
-    type AnyWithoutFn = Pick<Any, 'name' | 'schema' | 'options'>;
+	type Any = EventDef<string, any, any, boolean>;
+	type AnyWithoutFn = Pick<Any, "name" | "schema" | "options">;
 }
 export type EventDefKey = string;
 export type EventDefFact = string;
 export type EventDefFacts = ReadonlyMap<string, any>;
 export type EventDefFactsGroup = {
-    modifySet: EventDefFacts;
-    modifyUnset: EventDefFacts;
-    /**
-     * Events on independent "dependency" branches are commutative which can facilitate more prioritized syncing
-     */
-    depRequire: EventDefFacts;
-    depRead: EventDefFacts;
+	modifySet: EventDefFacts;
+	modifyUnset: EventDefFacts;
+	/**
+	 * Events on independent "dependency" branches are commutative which can facilitate more prioritized syncing
+	 */
+	depRequire: EventDefFacts;
+	depRead: EventDefFacts;
 };
 export type EventDefFactsSnapshot = Map<string, any>;
 export type EventDefFactInput = string | readonly [string, any];
-export declare const defineFacts: <TRecord extends Record<string, EventDefFactInput | ((...args: any[]) => EventDefFactInput)>>(record: TRecord) => TRecord;
+export declare const defineFacts: <
+	TRecord extends Record<
+		string,
+		EventDefFactInput | ((...args: any[]) => EventDefFactInput)
+	>,
+>(
+	record: TRecord,
+) => TRecord;
 export type DefineEventOptions<TTo, TDerived extends boolean = false> = {
-    /** Warning: This feature is not fully implemented yet */
-    facts?: (args: TTo, currentFacts: EventDefFacts) => {
-        modify?: {
-            set?: Iterable<EventDefFactInput>;
-            unset?: Iterable<EventDefFactInput>;
-        };
-        /**
-         * Two purposes: constrain history and constrain compaction
-         */
-        require?: Iterable<EventDefFactInput>;
-    };
-    /**
-     * When set to true, the event won't be synced over the network
-     */
-    clientOnly?: boolean;
-    derived?: TDerived;
+	/** Warning: This feature is not fully implemented yet */
+	facts?: (
+		args: TTo,
+		currentFacts: EventDefFacts,
+	) => {
+		modify?: {
+			set?: Iterable<EventDefFactInput>;
+			unset?: Iterable<EventDefFactInput>;
+		};
+		/**
+		 * Two purposes: constrain history and constrain compaction
+		 */
+		require?: Iterable<EventDefFactInput>;
+	};
+	/**
+	 * When set to true, the event won't be synced over the network
+	 */
+	clientOnly?: boolean;
+	derived?: TDerived;
 };
-export declare const defineEvent: <TName extends string, TType, TEncoded = TType, TDerived extends boolean = false>(args: {
-    name: TName;
-    schema: Schema.Schema<TType, TEncoded>;
-} & DefineEventOptions<TType, TDerived>) => EventDef<TName, TType, TEncoded, TDerived>;
-export declare const synced: <TName extends string, TType, TEncoded = TType>(args: {
-    name: TName;
-    schema: Schema.Schema<TType, TEncoded>;
-} & Omit<DefineEventOptions<TType, false>, "derived" | "clientOnly">) => EventDef<TName, TType, TEncoded>;
-export declare const clientOnly: <TName extends string, TType, TEncoded = TType>(args: {
-    name: TName;
-    schema: Schema.Schema<TType, TEncoded>;
-} & Omit<DefineEventOptions<TType, false>, "derived" | "clientOnly">) => EventDef<TName, TType, TEncoded>;
-export type MaterializerResult = {
-    sql: string;
-    bindValues: BindValues;
-    writeTables?: ReadonlySet<string>;
-} | QueryBuilder.Any | string;
+export declare const defineEvent: <
+	TName extends string,
+	TType,
+	TEncoded = TType,
+	TDerived extends boolean = false,
+>(
+	args: {
+		name: TName;
+		schema: Schema.Schema<TType, TEncoded>;
+	} & DefineEventOptions<TType, TDerived>,
+) => EventDef<TName, TType, TEncoded, TDerived>;
+export declare const synced: <TName extends string, TType, TEncoded = TType>(
+	args: {
+		name: TName;
+		schema: Schema.Schema<TType, TEncoded>;
+	} & Omit<DefineEventOptions<TType, false>, "derived" | "clientOnly">,
+) => EventDef<TName, TType, TEncoded>;
+export declare const clientOnly: <
+	TName extends string,
+	TType,
+	TEncoded = TType,
+>(
+	args: {
+		name: TName;
+		schema: Schema.Schema<TType, TEncoded>;
+	} & Omit<DefineEventOptions<TType, false>, "derived" | "clientOnly">,
+) => EventDef<TName, TType, TEncoded>;
+export type MaterializerResult =
+	| {
+			sql: string;
+			bindValues: BindValues;
+			writeTables?: ReadonlySet<string>;
+	  }
+	| QueryBuilder.Any
+	| string;
 export type MaterializerContextQuery = {
-    (args: {
-        query: string;
-        bindValues: ParamsObject;
-    }): ReadonlyArray<unknown>;
-    <TResult>(qb: QueryBuilder<TResult, any, any>): TResult;
+	(args: { query: string; bindValues: ParamsObject }): ReadonlyArray<unknown>;
+	<TResult>(qb: QueryBuilder<TResult, any, any>): TResult;
 };
-export type Materializer<TEventDef extends EventDef.AnyWithoutFn = EventDef.AnyWithoutFn> = (event: TEventDef['schema']['Type'], context: {
-    currentFacts: EventDefFacts;
-    eventDef: TEventDef;
-    /** Can be used to query the current state */
-    query: MaterializerContextQuery;
-}) => SingleOrReadonlyArray<MaterializerResult>;
-export declare const defineMaterializer: <TEventDef extends EventDef.AnyWithoutFn>(_eventDef: TEventDef, materializer: Materializer<TEventDef>) => Materializer<TEventDef>;
-export declare const materializers: <TInputRecord extends Record<string, EventDef.AnyWithoutFn>>(_eventDefRecord: TInputRecord, handlers: { [TEventName in TInputRecord[keyof TInputRecord]["name"] as Extract<TInputRecord[keyof TInputRecord], {
-    name: TEventName;
-}>["options"]["derived"] extends true ? never : TEventName]: Materializer<Extract<TInputRecord[keyof TInputRecord], {
-    name: TEventName;
-}>>; }) => { [TEventName in TInputRecord[keyof TInputRecord]["name"] as Extract<TInputRecord[keyof TInputRecord], {
-    name: TEventName;
-}>["options"]["derived"] extends true ? never : TEventName]: Materializer<Extract<TInputRecord[keyof TInputRecord], {
-    name: TEventName;
-}>>; };
-//# sourceMappingURL=EventDef.d.ts.map
+export type Materializer<
+	TEventDef extends EventDef.AnyWithoutFn = EventDef.AnyWithoutFn,
+> = (
+	event: TEventDef["schema"]["Type"],
+	context: {
+		currentFacts: EventDefFacts;
+		eventDef: TEventDef;
+		/** Can be used to query the current state */
+		query: MaterializerContextQuery;
+	},
+) => SingleOrReadonlyArray<MaterializerResult>;
+export declare const defineMaterializer: <
+	TEventDef extends EventDef.AnyWithoutFn,
+>(
+	_eventDef: TEventDef,
+	materializer: Materializer<TEventDef>,
+) => Materializer<TEventDef>;
+export declare const materializers: <
+	TInputRecord extends Record<string, EventDef.AnyWithoutFn>,
+>(
+	_eventDefRecord: TInputRecord,
+	handlers: {
+		[TEventName in TInputRecord[keyof TInputRecord]["name"] as Extract<
+			TInputRecord[keyof TInputRecord],
+			{
+				name: TEventName;
+			}
+		>["options"]["derived"] extends true
+			? never
+			: TEventName]: Materializer<
+			Extract<
+				TInputRecord[keyof TInputRecord],
+				{
+					name: TEventName;
+				}
+			>
+		>;
+	},
+) => {
+	[TEventName in TInputRecord[keyof TInputRecord]["name"] as Extract<
+		TInputRecord[keyof TInputRecord],
+		{
+			name: TEventName;
+		}
+	>["options"]["derived"] extends true
+		? never
+		: TEventName]: Materializer<
+		Extract<
+			TInputRecord[keyof TInputRecord],
+			{
+				name: TEventName;
+			}
+		>
+	>;
+};
+//# sourceMappingURL=EventDef.d.ts.map

package/dist/schema/state/sqlite/db-schema/dsl/mod.d.ts

@@ -1,40 +1,79 @@
-import type { Nullable } from '@livestore/utils';
-import type { Option, Types } from '@livestore/utils/effect';
-import { Schema } from '@livestore/utils/effect';
-import type * as SqliteAst from '../ast/sqlite.ts';
-import type { ColumnDefinition } from './field-defs.ts';
-export * from './field-defs.ts';
+import type { Option, Schema, Types } from "@livestore/utils/effect";
+import type { Nullable } from "../../../../../../../utils/dist/mod.ts";
+import type * as SqliteAst from "../ast/sqlite.ts";
+import type { ColumnDefinition } from "./field-defs.ts";
+
+export * from "./field-defs.ts";
 export type DbSchema = {
-    [key: string]: TableDefinition<string, Columns>;
+	[key: string]: TableDefinition<string, Columns>;
 };
 /** Note when using the object-notation, the object keys are ignored and not used as table names */
-export type DbSchemaInput = Record<string, TableDefinition<any, any>> | ReadonlyArray<TableDefinition<any, any>>;
+export type DbSchemaInput =
+	| Record<string, TableDefinition<any, any>>
+	| ReadonlyArray<TableDefinition<any, any>>;
 /**
  * In case of ...
  * - array: we use the table name of each array item (= table definition) as the object key
  * - object: we discard the keys of the input object and use the table name of each object value (= table definition) as the new object key
  */
-export type DbSchemaFromInputSchema<TSchemaInput extends DbSchemaInput> = TSchemaInput extends ReadonlyArray<TableDefinition<any, any>> ? {
-    [K in TSchemaInput[number] as K['name']]: K;
-} : TSchemaInput extends Record<string, TableDefinition<any, any>> ? {
-    [K in keyof TSchemaInput as TSchemaInput[K]['name']]: TSchemaInput[K];
-} : never;
-export declare const makeDbSchema: <TDbSchemaInput extends DbSchemaInput>(schema: TDbSchemaInput) => DbSchemaFromInputSchema<TDbSchemaInput>;
-export declare const table: <TTableName extends string, TColumns extends Columns, TIndexes extends Index[]>(name: TTableName, columns: TColumns, indexes?: TIndexes) => TableDefinition<TTableName, TColumns>;
-export type AnyIfConstained<In, Out> = '__constrained' extends keyof In ? any : Out;
-export type EmptyObjIfConstained<In> = '__constrained' extends keyof In ? {} : In;
-export type StructSchemaForColumns<TCols extends ConstraintColumns> = Schema.Schema<AnyIfConstained<TCols, FromColumns.RowDecoded<TCols>>, AnyIfConstained<TCols, FromColumns.RowEncoded<TCols>>>;
-export type InsertStructSchemaForColumns<TCols extends ConstraintColumns> = Schema.Schema<AnyIfConstained<TCols, FromColumns.InsertRowDecoded<TCols>>, AnyIfConstained<TCols, FromColumns.InsertRowEncoded<TCols>>>;
-export declare const structSchemaForTable: <TTableDefinition extends TableDefinition<any, any>>(tableDef: TTableDefinition) => StructSchemaForColumns<TTableDefinition["columns"]>;
-export declare const insertStructSchemaForTable: <TTableDefinition extends TableDefinition<any, any>>(tableDef: TTableDefinition) => InsertStructSchemaForColumns<TTableDefinition["columns"]>;
+export type DbSchemaFromInputSchema<TSchemaInput extends DbSchemaInput> =
+	TSchemaInput extends ReadonlyArray<TableDefinition<any, any>>
+		? {
+				[K in TSchemaInput[number] as K["name"]]: K;
+			}
+		: TSchemaInput extends Record<string, TableDefinition<any, any>>
+			? {
+					[K in keyof TSchemaInput as TSchemaInput[K]["name"]]: TSchemaInput[K];
+				}
+			: never;
+export declare const makeDbSchema: <TDbSchemaInput extends DbSchemaInput>(
+	schema: TDbSchemaInput,
+) => DbSchemaFromInputSchema<TDbSchemaInput>;
+export declare const table: <
+	TTableName extends string,
+	TColumns extends Columns,
+	TIndexes extends Index[],
+>(
+	name: TTableName,
+	columns: TColumns,
+	indexes?: TIndexes,
+) => TableDefinition<TTableName, TColumns>;
+export type AnyIfConstained<In, Out> = "__constrained" extends keyof In
+	? any
+	: Out;
+export type EmptyObjIfConstained<In> = "__constrained" extends keyof In
+	? {}
+	: In;
+export type StructSchemaForColumns<TCols extends ConstraintColumns> =
+	Schema.Schema<
+		AnyIfConstained<TCols, FromColumns.RowDecoded<TCols>>,
+		AnyIfConstained<TCols, FromColumns.RowEncoded<TCols>>
+	>;
+export type InsertStructSchemaForColumns<TCols extends ConstraintColumns> =
+	Schema.Schema<
+		AnyIfConstained<TCols, FromColumns.InsertRowDecoded<TCols>>,
+		AnyIfConstained<TCols, FromColumns.InsertRowEncoded<TCols>>
+	>;
+export declare const structSchemaForTable: <
+	TTableDefinition extends TableDefinition<any, any>,
+>(
+	tableDef: TTableDefinition,
+) => StructSchemaForColumns<TTableDefinition["columns"]>;
+export declare const insertStructSchemaForTable: <
+	TTableDefinition extends TableDefinition<any, any>,
+>(
+	tableDef: TTableDefinition,
+) => InsertStructSchemaForColumns<TTableDefinition["columns"]>;
 export type TableDefinition<TName extends string, TColumns extends Columns> = {
-    name: TName;
-    columns: TColumns;
-    indexes?: ReadonlyArray<Index>;
-    ast: SqliteAst.Table;
+	name: TName;
+	columns: TColumns;
+	indexes?: ReadonlyArray<Index>;
+	ast: SqliteAst.Table;
 };
 export type Columns = Record<string, ColumnDefinition<any, any>>;
-export type IsSingleColumn<TColumns extends Columns | ColumnDefinition<any, any>> = TColumns extends ColumnDefinition<any, any> ? true : false;
+export type IsSingleColumn<
+	TColumns extends Columns | ColumnDefinition<any, any>,
+> = TColumns extends ColumnDefinition<any, any> ? true : false;
 /**
  * NOTE this is only needed to avoid a TS limitation where `StructSchemaForColumns` in the default case
  * results in `Record<string, any>` instead of `any`. (Thanks to Andarist for the workaround)
@@ -42,49 +81,110 @@ export type IsSingleColumn<TColumns extends Columns | ColumnDefinition<any, any>
  * Hopefully this can be removed in the future
  */
 export type ConstraintColumns = Record<string, ColumnDefinition<any, any>> & {
-    __constrained?: never;
+	__constrained?: never;
 };
 export type Index = {
-    name: string;
-    columns: ReadonlyArray<string>;
-    /** @default false */
-    isUnique?: boolean;
+	name: string;
+	columns: ReadonlyArray<string>;
+	/** @default false */
+	isUnique?: boolean;
 };
 export declare namespace FromTable {
-    type RowDecoded<TTableDefinition extends TableDefinition<any, any>> = Types.Simplify<Nullable<Pick<RowDecodedAll<TTableDefinition>, NullableColumnNames<TTableDefinition>>> & Omit<RowDecodedAll<TTableDefinition>, NullableColumnNames<TTableDefinition>>>;
-    type NullableColumnNames<TTableDefinition extends TableDefinition<any, any>> = FromColumns.NullableColumnNames<TTableDefinition['columns']>;
-    type Columns<TTableDefinition extends TableDefinition<any, any>> = {
-        [K in keyof TTableDefinition['columns']]: TTableDefinition['columns'][K]['columnType'];
-    };
-    type RowEncodeNonNullable<TTableDefinition extends TableDefinition<any, any>> = {
-        [K in keyof TTableDefinition['columns']]: Schema.Schema.Encoded<TTableDefinition['columns'][K]['schema']>;
-    };
-    type RowEncoded<TTableDefinition extends TableDefinition<any, any>> = Types.Simplify<Nullable<Pick<RowEncodeNonNullable<TTableDefinition>, NullableColumnNames<TTableDefinition>>> & Omit<RowEncodeNonNullable<TTableDefinition>, NullableColumnNames<TTableDefinition>>>;
-    type RowDecodedAll<TTableDefinition extends TableDefinition<any, any>> = {
-        [K in keyof TTableDefinition['columns']]: Schema.Schema.Type<TTableDefinition['columns'][K]['schema']>;
-    };
+	type RowDecoded<TTableDefinition extends TableDefinition<any, any>> =
+		Types.Simplify<
+			Nullable<
+				Pick<
+					RowDecodedAll<TTableDefinition>,
+					NullableColumnNames<TTableDefinition>
+				>
+			> &
+				Omit<
+					RowDecodedAll<TTableDefinition>,
+					NullableColumnNames<TTableDefinition>
+				>
+		>;
+	type NullableColumnNames<TTableDefinition extends TableDefinition<any, any>> =
+		FromColumns.NullableColumnNames<TTableDefinition["columns"]>;
+	type Columns<TTableDefinition extends TableDefinition<any, any>> = {
+		[K in keyof TTableDefinition["columns"]]: TTableDefinition["columns"][K]["columnType"];
+	};
+	type RowEncodeNonNullable<
+		TTableDefinition extends TableDefinition<any, any>,
+	> = {
+		[K in keyof TTableDefinition["columns"]]: Schema.Schema.Encoded<
+			TTableDefinition["columns"][K]["schema"]
+		>;
+	};
+	type RowEncoded<TTableDefinition extends TableDefinition<any, any>> =
+		Types.Simplify<
+			Nullable<
+				Pick<
+					RowEncodeNonNullable<TTableDefinition>,
+					NullableColumnNames<TTableDefinition>
+				>
+			> &
+				Omit<
+					RowEncodeNonNullable<TTableDefinition>,
+					NullableColumnNames<TTableDefinition>
+				>
+		>;
+	type RowDecodedAll<TTableDefinition extends TableDefinition<any, any>> = {
+		[K in keyof TTableDefinition["columns"]]: Schema.Schema.Type<
+			TTableDefinition["columns"][K]["schema"]
+		>;
+	};
 }
 export declare namespace FromColumns {
-    type RowDecoded<TColumns extends Columns> = Types.Simplify<Nullable<Pick<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>> & Omit<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>>;
-    type RowDecodedAll<TColumns extends Columns> = {
-        readonly [K in keyof TColumns]: Schema.Schema.Type<TColumns[K]['schema']>;
-    };
-    type RowEncodedAll<TColumns extends Columns> = {
-        readonly [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>;
-    };
-    type RowEncoded<TColumns extends Columns> = Types.Simplify<Nullable<Pick<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>> & Omit<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>>;
-    type RowEncodeNonNullable<TColumns extends Columns> = {
-        readonly [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>;
-    };
-    type NullableColumnNames<TColumns extends Columns> = keyof {
-        [K in keyof TColumns as TColumns[K] extends ColumnDefinition<any, true> ? K : never]: {};
-    };
-    type RequiredInsertColumns<TColumns extends Columns> = {
-        [K in keyof TColumns as TColumns[K]['nullable'] extends true ? never : TColumns[K]['default'] extends Option.Some<any> ? never : K]: {};
-    };
-    type RequiredInsertColumnNames<TColumns extends Columns> = keyof RequiredInsertColumns<TColumns>;
-    type RequiresInsertValues<TColumns extends Columns> = RequiredInsertColumnNames<TColumns> extends never ? false : true;
-    type InsertRowDecoded<TColumns extends Columns> = Types.Simplify<Pick<RowDecodedAll<TColumns>, RequiredInsertColumnNames<TColumns>> & Partial<Omit<RowDecodedAll<TColumns>, RequiredInsertColumnNames<TColumns>>>>;
-    type InsertRowEncoded<TColumns extends Columns> = Types.Simplify<Pick<RowEncodedAll<TColumns>, RequiredInsertColumnNames<TColumns>> & Partial<Omit<RowEncodedAll<TColumns>, RequiredInsertColumnNames<TColumns>>>>;
+	type RowDecoded<TColumns extends Columns> = Types.Simplify<
+		Nullable<Pick<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>> &
+			Omit<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>
+	>;
+	type RowDecodedAll<TColumns extends Columns> = {
+		readonly [K in keyof TColumns]: Schema.Schema.Type<TColumns[K]["schema"]>;
+	};
+	type RowEncodedAll<TColumns extends Columns> = {
+		readonly [K in keyof TColumns]: Schema.Schema.Encoded<
+			TColumns[K]["schema"]
+		>;
+	};
+	type RowEncoded<TColumns extends Columns> = Types.Simplify<
+		Nullable<
+			Pick<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>
+		> &
+			Omit<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>
+	>;
+	type RowEncodeNonNullable<TColumns extends Columns> = {
+		readonly [K in keyof TColumns]: Schema.Schema.Encoded<
+			TColumns[K]["schema"]
+		>;
+	};
+	type NullableColumnNames<TColumns extends Columns> = keyof {
+		[K in keyof TColumns as TColumns[K] extends ColumnDefinition<any, true>
+			? K
+			: never]: {};
+	};
+	type RequiredInsertColumns<TColumns extends Columns> = {
+		[K in keyof TColumns as TColumns[K]["nullable"] extends true
+			? never
+			: TColumns[K]["default"] extends Option.Some<any>
+				? never
+				: K]: {};
+	};
+	type RequiredInsertColumnNames<TColumns extends Columns> =
+		keyof RequiredInsertColumns<TColumns>;
+	type RequiresInsertValues<TColumns extends Columns> =
+		RequiredInsertColumnNames<TColumns> extends never ? false : true;
+	type InsertRowDecoded<TColumns extends Columns> = Types.Simplify<
+		Pick<RowDecodedAll<TColumns>, RequiredInsertColumnNames<TColumns>> &
+			Partial<
+				Omit<RowDecodedAll<TColumns>, RequiredInsertColumnNames<TColumns>>
+			>
+	>;
+	type InsertRowEncoded<TColumns extends Columns> = Types.Simplify<
+		Pick<RowEncodedAll<TColumns>, RequiredInsertColumnNames<TColumns>> &
+			Partial<
+				Omit<RowEncodedAll<TColumns>, RequiredInsertColumnNames<TColumns>>
+			>
+	>;
 }
-//# sourceMappingURL=mod.d.ts.map
+//# sourceMappingURL=mod.d.ts.map