@tulip-systems/core 0.9.0 → 0.10.0

package/src/modules/commands/lib/registery.ts

@@ -1,10 +1,66 @@
-import type z from "zod";
-import type { CommandDef } from "./builder";
+import type { AnyCommandDef } from "./builder";
 
 /**
  * Command map type defining the shape of command definitions.
  */
-export type CommandMap = Record<string, CommandDef<z.ZodTypeAny, any>>;
+export type CommandMap = Record<string, AnyCommandDef>;
+
+/** Union of all values in a command map. */
+type ValueOf<TCommands extends CommandMap> = TCommands[keyof TCommands];
+
+// ─── Tag filter type helpers ───────────────────────────────────────────────────
+// Each helper checks ONLY the `tags` field to avoid function-type variance issues.
+// Commands with non-literal `string[]` tags are always kept (conservative fallback).
+
+/** Keep commands that have **every** of `TFilterTags`. */
+type FilterAllTags<
+  TCommand extends AnyCommandDef,
+  TFilterTags extends readonly string[],
+> = TCommand extends { tags: infer CmdTags extends readonly string[] }
+  ? TFilterTags[number] extends CmdTags[number]
+    ? TCommand
+    : never
+  : TCommand;
+
+/** Keep commands that have **some** of `TFilterTags`. */
+type FilterAnyTags<
+  TCommand extends AnyCommandDef,
+  TFilterTags extends readonly string[],
+> = TCommand extends { tags: infer CmdTags extends readonly string[] }
+  ? string[] extends CmdTags
+    ? TCommand
+    : Extract<CmdTags[number], TFilterTags[number]> extends never
+      ? never
+      : TCommand
+  : TCommand;
+
+/** Keep commands whose tag set equals `TFilterTags` (order-insensitive). */
+type FilterExactTags<
+  TCommand extends AnyCommandDef,
+  TFilterTags extends readonly string[],
+> = TCommand extends { tags: infer CmdTags extends readonly string[] }
+  ? string[] extends CmdTags
+    ? TCommand
+    : [CmdTags[number]] extends [TFilterTags[number]]
+      ? [TFilterTags[number]] extends [CmdTags[number]]
+        ? TCommand
+        : never
+      : never
+  : TCommand;
+
+/** Keep commands that have **without** of `TFilterTags`. */
+type FilterWithoutTags<
+  TCommand extends AnyCommandDef,
+  TFilterTags extends readonly string[],
+> = TCommand extends { tags: infer CmdTags extends readonly string[] }
+  ? string[] extends CmdTags
+    ? TCommand
+    : Extract<CmdTags[number], TFilterTags[number]> extends never
+      ? TCommand
+      : never
+  : TCommand;
+
+// ─── Registry type definitions ─────────────────────────────────────────────────
 
 type CommandKey<TCommands extends CommandMap> = Extract<keyof TCommands, string>;
 type CommandFlags<TCommands extends CommandMap> = Partial<Record<CommandKey<TCommands>, boolean>>;
@@ -12,9 +68,7 @@ type CommandInput<TCommands extends CommandMap> =
   | readonly CommandKey<TCommands>[]
   | CommandFlags<TCommands>;
 
-type TruthyKeys<T> = {
-  [K in keyof T]-?: T[K] extends true ? K : never;
-}[keyof T];
+type TruthyKeys<T> = { [K in keyof T]-?: T[K] extends true ? K : never }[keyof T];
 
 type PickedCommands<
   TCommands extends CommandMap,
@@ -22,8 +76,8 @@ type PickedCommands<
 > = TInput extends readonly CommandKey<TCommands>[]
   ? Pick<TCommands, TInput[number]>
   : TInput extends CommandFlags<TCommands>
-      ? Pick<TCommands, Extract<TruthyKeys<TInput>, keyof TCommands>>
-      : never;
+    ? Pick<TCommands, Extract<TruthyKeys<TInput>, keyof TCommands>>
+    : never;
 
 type OmittedCommands<
   TCommands extends CommandMap,
@@ -31,8 +85,8 @@ type OmittedCommands<
 > = TInput extends readonly CommandKey<TCommands>[]
   ? Omit<TCommands, TInput[number]>
   : TInput extends CommandFlags<TCommands>
-      ? Omit<TCommands, Extract<TruthyKeys<TInput>, keyof TCommands>>
-      : never;
+    ? Omit<TCommands, Extract<TruthyKeys<TInput>, keyof TCommands>>
+    : never;
 
 type ExtendedCommands<TBase extends CommandMap, TExtension extends CommandMap> = Omit<
   TBase,
@@ -40,74 +94,183 @@ type ExtendedCommands<TBase extends CommandMap, TExtension extends CommandMap> =
 > &
   TExtension;
 
-/**
- * Command registry type with utility methods for picking, omitting, and converting to array.
- * This allows for flexible manipulation of command sets while maintaining type safety.
- */
+type CommandTagFilterRegistry<TCommand extends AnyCommandDef> = {
+  every<const TTags extends string[]>(
+    ...tags: TTags
+  ): CommandTagFilterRegistry<FilterAllTags<TCommand, TTags>>;
+  some<const TTags extends string[]>(
+    ...tags: TTags
+  ): CommandTagFilterRegistry<FilterAnyTags<TCommand, TTags>>;
+  exact<const TTags extends string[]>(
+    ...tags: TTags
+  ): CommandTagFilterRegistry<FilterExactTags<TCommand, TTags>>;
+  without<const TTags extends string[]>(
+    ...tags: TTags
+  ): CommandTagFilterRegistry<FilterWithoutTags<TCommand, TTags>>;
+  toArray(): TCommand[];
+};
+
+type CommandKeyFilterRegistry<TCommands extends CommandMap> = {
+  pick<const TInput extends CommandInput<TCommands>>(
+    input: TInput,
+  ): CommandKeyFilterRegistry<PickedCommands<TCommands, TInput>>;
+  omit<const TInput extends CommandInput<TCommands>>(
+    input: TInput,
+  ): CommandKeyFilterRegistry<OmittedCommands<TCommands, TInput>>;
+  toArray(): ValueOf<TCommands>[];
+};
+
 type CommandRegistry<TCommands extends CommandMap> = {
   commands: TCommands;
+  keys: CommandKeyFilterRegistry<TCommands>;
+  tags: CommandTagFilterRegistry<ValueOf<TCommands>>;
   extend<const TExtension extends CommandMap>(
     extension: TExtension,
   ): CommandRegistry<ExtendedCommands<TCommands, TExtension>>;
+  /** @deprecated Use `commands.keys.pick(...)` instead. */
   pick<const TInput extends CommandInput<TCommands>>(
     input: TInput,
   ): CommandRegistry<PickedCommands<TCommands, TInput>>;
+  /** @deprecated Use `commands.keys.omit(...)` instead. */
   omit<const TInput extends CommandInput<TCommands>>(
     input: TInput,
   ): CommandRegistry<OmittedCommands<TCommands, TInput>>;
-  toArray(): Array<CommandDef<z.ZodTypeAny, any>>;
+  toArray(): ValueOf<TCommands>[];
 };
 
-function toKeys<TCommands extends CommandMap>(
+// ─── Runtime helpers ───────────────────────────────────────────────────────────
+
+function resolveKeys<TCommands extends CommandMap>(
   input: CommandInput<TCommands>,
-): Array<CommandKey<TCommands>> {
+): CommandKey<TCommands>[] {
   if (Array.isArray(input)) return [...input];
-
-  return (Object.entries(input) as Array<[CommandKey<TCommands>, boolean | undefined]>)
+  return Object.entries(input)
     .filter(([, enabled]) => enabled === true)
-    .map(([key]) => key);
+    .map(([key]) => key as CommandKey<TCommands>);
 }
 
-/**
- * Internal function to create a command registry from a given command map.
- */
-function createRegistry<TCommands extends CommandMap>(
+function dedupe(tags: readonly string[]) {
+  return [...new Set(tags)];
+}
+
+function hasEveryTag(command: AnyCommandDef, tags: readonly string[]) {
+  return tags.every((tag) => command.tags.includes(tag));
+}
+
+function hasSomeTag(command: AnyCommandDef, tags: readonly string[]) {
+  return tags.some((tag) => command.tags.includes(tag));
+}
+
+function hasExactTags(command: AnyCommandDef, tags: readonly string[]) {
+  const ctags = dedupe(command.tags);
+  const ftags = dedupe(tags);
+  return ctags.length === ftags.length && ftags.every((t) => ctags.includes(t));
+}
+
+function injectIds<TCommands extends CommandMap>(commands: TCommands): TCommands {
+  return Object.fromEntries(
+    Object.entries(commands).map(([id, c]) => [id, { ...c, id }]),
+  ) as TCommands;
+}
+
+function pickCommands<TCommands extends CommandMap, TInput extends CommandInput<TCommands>>(
   commands: TCommands,
-): CommandRegistry<TCommands> {
+  input: TInput,
+): PickedCommands<TCommands, TInput> {
+  const keys = resolveKeys<TCommands>(input);
+  return Object.fromEntries(
+    keys.filter((k) => k in commands).map((k) => [k, commands[k]]),
+  ) as PickedCommands<TCommands, TInput>;
+}
+
+function omitCommands<TCommands extends CommandMap, TInput extends CommandInput<TCommands>>(
+  commands: TCommands,
+  input: TInput,
+): OmittedCommands<TCommands, TInput> {
+  const keys = new Set(resolveKeys<TCommands>(input));
+  return Object.fromEntries(
+    Object.entries(commands).filter(([k]) => !keys.has(k as CommandKey<TCommands>)),
+  ) as OmittedCommands<TCommands, TInput>;
+}
+
+function createTagFilterRegistry<TCommand extends AnyCommandDef>(
+  commands: TCommand[],
+): CommandTagFilterRegistry<TCommand> {
+  function apply<const TTags extends string[]>(
+    predicate: (cmd: AnyCommandDef, tags: readonly string[]) => boolean,
+  ) {
+    return (...tags: TTags) => {
+      const filtered = commands.filter((c) => predicate(c, tags));
+      return createTagFilterRegistry(filtered) as CommandTagFilterRegistry<any>;
+    };
+  }
+
   return {
-    commands,
-    extend<const TExtension extends CommandMap>(extension: TExtension) {
-      const next = { ...commands, ...extension } as ExtendedCommands<TCommands, TExtension>;
-      return createRegistry(next);
+    every: apply(hasEveryTag) as CommandTagFilterRegistry<TCommand>["every"],
+    some: apply(hasSomeTag) as CommandTagFilterRegistry<TCommand>["some"],
+    exact: apply(hasExactTags) as CommandTagFilterRegistry<TCommand>["exact"],
+    without: apply((c, ts) => !hasSomeTag(c, ts)) as CommandTagFilterRegistry<TCommand>["without"],
+    toArray() {
+      return commands;
     },
-    pick<const TInput extends CommandInput<TCommands>>(input: TInput) {
-      const keys = toKeys<TCommands>(input);
-      const next = Object.fromEntries(
-        keys.flatMap((key) => (key in commands ? [[key, commands[key]]] : [])),
-      ) as PickedCommands<TCommands, TInput>;
+  };
+}
 
-      return createRegistry(next);
+function createKeyFilterRegistry<TCommands extends CommandMap>(
+  commands: TCommands,
+): CommandKeyFilterRegistry<TCommands> {
+  return {
+    pick<const TInput extends CommandInput<TCommands>>(input: TInput) {
+      return createKeyFilterRegistry(pickCommands(commands, input));
     },
     omit<const TInput extends CommandInput<TCommands>>(input: TInput) {
-      const keys = toKeys<TCommands>(input);
-      const blacklist = new Set(keys);
-      const next = Object.fromEntries(
-        Object.entries(commands).filter(([key]) => !blacklist.has(key as CommandKey<TCommands>)),
-      ) as OmittedCommands<TCommands, TInput>;
-
-      return createRegistry(next);
+      return createKeyFilterRegistry(omitCommands(commands, input));
     },
     toArray() {
-      return Object.values(commands) as Array<CommandDef<z.ZodTypeAny, any>>;
+      return Object.values(commands) as ValueOf<TCommands>[];
     },
   };
 }
 
+function createRegistry<TCommands extends CommandMap>(
+  commands: TCommands,
+): CommandRegistry<TCommands> {
+  const withIds = injectIds(commands);
+  const keys = createKeyFilterRegistry(withIds);
+
+  return {
+    commands: withIds,
+    keys,
+    tags: createTagFilterRegistry(Object.values(withIds) as ValueOf<TCommands>[]),
+    extend<const TExtension extends CommandMap>(extension: TExtension) {
+      return createRegistry({ ...withIds, ...extension } as ExtendedCommands<
+        TCommands,
+        TExtension
+      >);
+    },
+    pick(input) {
+      return createRegistry(pickCommands(withIds, input as CommandInput<TCommands>));
+    },
+    omit(input) {
+      return createRegistry(omitCommands(withIds, input as CommandInput<TCommands>));
+    },
+    toArray() {
+      return Object.values(withIds) as ValueOf<TCommands>[];
+    },
+  } as CommandRegistry<TCommands>;
+}
+
 /**
- * Public function to define commands. It takes a command map and returns a command registry with utility methods.
- * This is the main entry point for users to create their command sets.
- * @param commands - A map of command definitions keyed by command name.
- * @returns A command registry with the defined commands and utility methods.
+ * Define commands from a map of name → `CommandDef`.
+ *
+ * Returns a `CommandRegistry` with key-based and tag-based filtering, plus
+ * `extend` for composition. Filter chains are immutable — each call produces
+ * a new registry.
+ *
+ * @example
+ * const registry = defineCommands({ edit, delete, archive });
+ * registry.tags.every("danger", "table").toArray();
+ * registry.keys.omit({ delete: true }).toArray();
  */
 export function defineCommands<TCommands extends CommandMap>(
   commands: TCommands,

package/src/modules/commands/lib/utils.ts

@@ -0,0 +1,10 @@
+/**
+ * Normalizes command data into an array.
+ *
+ * Use this as a command transform when the same command should support both
+ * single-item and bulk contexts. After `.transform(ensureArray)`, command
+ * callbacks can safely use array helpers like `.map` and `.every`.
+ */
+export function ensureArray<T>(data: T | T[]) {
+  return Array.isArray(data) ? data : [data];
+}

package/src/modules/data-tables/components/footer.tsx

@@ -3,6 +3,7 @@
 import type { Table } from "@tanstack/react-table";
 import type { TableMeta } from "../lib/types";
 import { InfinteTableBottombar, InfinteTableFooter } from "../strategies/infinite/components";
+import { LocalTableFooter } from "../strategies/local/components";
 import { PaginationTableFooter } from "../strategies/pagination/components";
 
 /**
@@ -19,6 +20,10 @@ export function TableFooter<TData>({ table }: { table: Table<TData> }) {
     return <InfinteTableFooter table={table} />;
   }
 
+  if (meta.strategy.name === "local") {
+    return null;
+  }
+
   throw new Error(`Unknown strategy: ${meta.strategy.name}`);
 }
 
@@ -36,5 +41,9 @@ export function TableBottombar<TData>({ table }: { table: Table<TData> }) {
     return <InfinteTableBottombar table={table} />;
   }
 
+  if (meta.strategy.name === "local") {
+    return <LocalTableFooter table={table} />;
+  }
+
   throw new Error(`Unknown strategy: ${meta.strategy.name}`);
 }

package/src/modules/data-tables/entry.client.ts

@@ -19,6 +19,7 @@ export * from "./hooks/use-table.client";
  * Strategies
  */
 export * from "./strategies/infinite/strategy";
+export * from "./strategies/local/strategy";
 export * from "./strategies/pagination/strategy";
 /**
  * Data tables

package/src/modules/data-tables/hooks/use-context.client.tsx

@@ -10,7 +10,7 @@ import {
   useEffect,
   useState,
 } from "react";
-import type { CommandDef } from "@/modules/commands/lib/builder";
+import type { CommandFor } from "@/modules/commands/lib/builder";
 import type { TableFiltersResult } from "../lib/filters/config";
 import type { Selection, TableColumnDef, TableMetaInput, TableStrategy } from "../lib/types";
 
@@ -34,7 +34,7 @@ export type TableConfigContextValue<
   strategy: TableStrategy;
   selection?: Selection;
   columnVisibility?: VisibilityState;
-  commands?: CommandDef[];
+  commands?: CommandFor<TData[], TMeta>[];
   meta?: TMeta;
   where?: TFilters;
 };

package/src/modules/data-tables/lib/types.ts

@@ -8,7 +8,7 @@ import type {
 } from "@tanstack/react-table";
 import type { UseQueryStatesKeysMap } from "nuqs";
 import type { Permission } from "@/modules/auth/lib/permissions";
-import type { CommandDef } from "@/modules/commands/lib/builder";
+import type { CommandFor } from "@/modules/commands/lib/builder";
 
 /**
  * Data table meta
@@ -18,7 +18,7 @@ export type TableMetaInput<TData> = TanStackTableMeta<TData>;
 export type TableMeta<TData, TMeta = TableMetaInput<TData>> = {
   strategy: TableStrategy;
   selectedData: TData[];
-  commands?: CommandDef[];
+  commands?: CommandFor<TData[], TMeta>[];
 };
 
 /**
@@ -33,7 +33,7 @@ export type TableColumnDef<TData> = ColumnDef<TData> & {
  * Data table strategy
  */
 export type TableStrategy = {
-  name: "pagination" | "infinite";
+  name: "pagination" | "infinite" | "local";
   // Pagination
   rowCount?: number;
   paginationState?: PaginationState;

package/src/modules/data-tables/strategies/local/components.tsx

@@ -0,0 +1,17 @@
+"use client";
+
+import type { Table } from "@tanstack/react-table";
+
+export function LocalTableFooter<TData>({ table }: { table: Table<TData> }) {
+  const selected = Object.keys(table.getState().rowSelection).length;
+  const total = table.getRowCount();
+
+  return (
+    <div className="flex flex-col gap-y-2 px-2 md:flex-row md:items-center md:justify-between">
+      <div className="text-muted-foreground text-sm">
+        {selected ?? table.getFilteredSelectedRowModel().rows.length} of{" "}
+        {total ?? table.getRowModel().rows.length} row(s) selected.
+      </div>
+    </div>
+  );
+}

package/src/modules/data-tables/strategies/local/strategy.ts

@@ -0,0 +1,33 @@
+"use client";
+
+import type { SortingState } from "@tanstack/react-table";
+import { useQueryStates } from "nuqs";
+import { tableSearchParams } from "../../entry";
+import type { TableStrategy } from "../../lib/types";
+import { handleSortingChange } from "../helpers/sorting";
+
+export type UseLocalStrategyInput = {
+  total?: number;
+};
+
+export type LocalStrategy = typeof useLocalStrategy;
+
+export function useLocalStrategy({ total }: UseLocalStrategyInput = {}): TableStrategy {
+  const [query, setQuery] = useQueryStates(tableSearchParams);
+
+  const sortingState: SortingState = query.sort
+    ? [{ id: query.sort, desc: query.order === "desc" }]
+    : [];
+
+  const resetCursor = () => null;
+
+  return {
+    name: "local",
+    rowCount: total,
+    resetCursor,
+    tableSearchParams,
+    sortingState,
+    manualSorting: true,
+    onSortingChange: handleSortingChange({ sortingState, setQuery, resetCursor }),
+  };
+}

package/src/modules/inline/components/inputs/combobox-dropdown.client.tsx

@@ -19,15 +19,20 @@ import { type InlineEditVariantsProps, inlineEditVariants } from "../../lib/vari
 
 type ComboboxDropdownInlineTrigger = "commit";
 
+type InlineStringSchema =
+  | z.ZodType<string | null, string | null>
+  | z.ZodType<string, string>;
+
 export type InlineEditComboboxDropdownProps<
   TValue extends ComboboxDropdownItem,
+  TSchema extends InlineStringSchema = z.ZodType<string | null, string | null>,
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
   TOnMutateResult = unknown,
 > = useInlineEditOptions<
   ComboboxDropdownInlineTrigger,
-  z.ZodString | z.ZodNullable<z.ZodString>,
+  TSchema,
   TData,
   TError,
   TVariables,
@@ -40,6 +45,7 @@ export type InlineEditComboboxDropdownProps<
 
 export function InlineComboboxDropdown<
   TValue extends ComboboxDropdownItem,
+  TSchema extends InlineStringSchema = z.ZodType<string | null, string | null>,
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
@@ -56,11 +62,11 @@ export function InlineComboboxDropdown<
   strategy,
   disabled,
   ...props
-}: InlineEditComboboxDropdownProps<TValue, TData, TError, TVariables, TOnMutateResult>) {
+}: InlineEditComboboxDropdownProps<TValue, TSchema, TData, TError, TVariables, TOnMutateResult>) {
   const state = useInlineState<string | null>(initialValue);
   const access = useInlineAccess({ permission, disabled });
   const mutations = useInlineMutation<
-    z.ZodString | z.ZodNullable<z.ZodString>,
+    TSchema,
     string | null,
     TData,
     TError,
@@ -75,7 +81,7 @@ export function InlineComboboxDropdown<
 
   const { handleTrigger } = useInlineStrategy<
     ComboboxDropdownInlineTrigger,
-    z.ZodString | z.ZodNullable<z.ZodString>,
+    TSchema,
     string | null
   >({
     strategy,
@@ -83,7 +89,7 @@ export function InlineComboboxDropdown<
     mutations,
     parser: {
       decode: (value) => value,
-      encode: (value) => value,
+      encode: (value) => value as z.input<TSchema>,
     },
   });
 

package/src/modules/inline/components/inputs/combobox.client.tsx

@@ -13,15 +13,20 @@ import {
 
 type ComboboxInlineTrigger = "commit";
 
+type InlineStringSchema =
+  | z.ZodType<string | null, string | null>
+  | z.ZodType<string, string>;
+
 export type InlineComboboxProps<
   TValue,
+  TSchema extends InlineStringSchema = z.ZodType<string | null, string | null>,
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
   TOnMutateResult = unknown,
 > = useInlineEditOptions<
   ComboboxInlineTrigger,
-  z.ZodString | z.ZodNullable<z.ZodString>,
+  TSchema,
   TData,
   TError,
   TVariables,
@@ -31,6 +36,7 @@ export type InlineComboboxProps<
 
 export function InlineCombobox<
   TValue,
+  TSchema extends InlineStringSchema = z.ZodType<string | null, string | null>,
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
@@ -45,11 +51,11 @@ export function InlineCombobox<
   disabled,
   strategy,
   ...props
-}: InlineComboboxProps<TValue, TData, TError, TVariables, TOnMutateResult>) {
+}: InlineComboboxProps<TValue, TSchema, TData, TError, TVariables, TOnMutateResult>) {
   const state = useInlineState<string | null>(initialValue);
   const access = useInlineAccess({ permission, disabled });
   const mutations = useInlineMutation<
-    z.ZodString | z.ZodNullable<z.ZodString>,
+    TSchema,
     string | null,
     TData,
     TError,
@@ -64,7 +70,7 @@ export function InlineCombobox<
 
   const { handleTrigger } = useInlineStrategy<
     ComboboxInlineTrigger,
-    z.ZodString | z.ZodNullable<z.ZodString>,
+    TSchema,
     string | null
   >({
     strategy,
@@ -72,7 +78,7 @@ export function InlineCombobox<
     mutations,
     parser: {
       decode: (value) => value,
-      encode: (value) => value,
+      encode: (value) => value as z.input<TSchema>,
     },
   });
 

package/src/modules/inline/components/inputs/date-time.client.tsx

@@ -17,7 +17,12 @@ import { type InlineEditVariantsProps, inlineEditVariants } from "../../lib/vari
 
 type DateTimeInlineTrigger = "change" | "blur";
 
+type InlineDateTimeSchema =
+  | z.ZodType<Date | null, Date | null>
+  | z.ZodType<Date, Date>;
+
 type InlineDateTimeInputProps<
+  TSchema extends InlineDateTimeSchema = z.ZodType<Date | null, Date | null>,
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
@@ -25,7 +30,7 @@ type InlineDateTimeInputProps<
 > = ComponentProps<typeof DateTimeInput> &
   useInlineEditOptions<
     DateTimeInlineTrigger,
-    z.ZodDate | z.ZodNullable<z.ZodDate>,
+    TSchema,
     TData,
     TError,
     TVariables,
@@ -34,6 +39,7 @@ type InlineDateTimeInputProps<
   InlineEditVariantsProps;
 
 export function InlineDateTimeInput<
+  TSchema extends InlineDateTimeSchema = z.ZodType<Date | null, Date | null>,
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
@@ -48,13 +54,13 @@ export function InlineDateTimeInput<
   strategy,
   disabled,
   ...props
-}: InlineDateTimeInputProps<TData, TError, TVariables, TOnMutateResult>) {
+}: InlineDateTimeInputProps<TSchema, TData, TError, TVariables, TOnMutateResult>) {
   const state = useInlineState<string>(
     initialValue ? format(initialValue, "yyyy-MM-dd'T'HH:mm") : "",
   );
   const access = useInlineAccess({ permission, disabled });
   const mutations = useInlineMutation<
-    z.ZodDate | z.ZodNullable<z.ZodDate>,
+    TSchema,
     string,
     TData,
     TError,
@@ -69,7 +75,7 @@ export function InlineDateTimeInput<
 
   const { handleTrigger } = useInlineStrategy<
     DateTimeInlineTrigger,
-    z.ZodDate | z.ZodNullable<z.ZodDate>,
+    TSchema,
     string
   >({
     strategy,
@@ -77,7 +83,7 @@ export function InlineDateTimeInput<
     mutations,
     parser: {
       decode: (date) => (date ? format(date, "yyyy-MM-dd'T'HH:mm") : ""),
-      encode: (dateTime) => (dateTime ? new Date(dateTime) : null),
+      encode: (dateTime) => (dateTime ? new Date(dateTime) : null) as z.input<TSchema>,
     },
   });