diff --git a/packages/db/src/local-only.ts b/packages/db/src/local-only.ts
index d6590c61..19725bf2 100644
--- a/packages/db/src/local-only.ts
+++ b/packages/db/src/local-only.ts
@@ -3,6 +3,7 @@ import type {
   DeleteMutationFnParams,
   InsertMutationFnParams,
   OperationType,
+  ResolveInsertInput,
   ResolveType,
   SyncConfig,
   UpdateMutationFnParams,
@@ -26,7 +27,7 @@ import type { StandardSchemaV1 } from "@standard-schema/spec"
  * You should provide EITHER an explicit type OR a schema, but not both, as they would conflict.
  */
 export interface LocalOnlyCollectionConfig<
-  TExplicit = unknown,
+  TExplicit extends object = Record<string, unknown>,
   TSchema extends StandardSchemaV1 = never,
   TFallback extends Record<string, unknown> = Record<string, unknown>,
   TKey extends string | number = string | number,
@@ -51,7 +52,7 @@ export interface LocalOnlyCollectionConfig<
    */
   onInsert?: (
     params: InsertMutationFnParams<
-      ResolveType<TExplicit, TSchema, TFallback>,
+      ResolveInsertInput<TExplicit, TSchema, TFallback>,
       TKey,
       LocalOnlyCollectionUtils
     >
@@ -136,33 +137,56 @@ export interface LocalOnlyCollectionUtils extends UtilsRecord {}
  * )
  */
 export function localOnlyCollectionOptions<
-  TExplicit = unknown,
+  TExplicit extends object = Record<string, unknown>,
   TSchema extends StandardSchemaV1 = never,
   TFallback extends Record<string, unknown> = Record<string, unknown>,
   TKey extends string | number = string | number,
 >(
   config: LocalOnlyCollectionConfig<TExplicit, TSchema, TFallback, TKey>
-): CollectionConfig<ResolveType<TExplicit, TSchema, TFallback>, TKey> & {
+): CollectionConfig<
+  ResolveType<TExplicit, TSchema, TFallback>,
+  TKey,
+  TSchema,
+  ResolveInsertInput<TExplicit, TSchema, TFallback>
+> & {
   utils: LocalOnlyCollectionUtils
 } {
-  type ResolvedType = ResolveType<TExplicit, TSchema, TFallback>
+  type TItem = ResolveType<TExplicit, TSchema, TFallback>
+  type TInsertInput = ResolveInsertInput<TExplicit, TSchema, TFallback>
 
   const { initialData, onInsert, onUpdate, onDelete, ...restConfig } = config
 
   // Create the sync configuration with transaction confirmation capability
-  const syncResult = createLocalOnlySync<ResolvedType, TKey>(initialData)
+  const syncResult = createLocalOnlySync<TItem, TKey>(
+    initialData as Array<TItem> | undefined
+  )
 
   /**
    * Create wrapper handlers that call user handlers first, then confirm transactions
    * Wraps the user's onInsert handler to also confirm the transaction immediately
    */
   const wrappedOnInsert = async (
-    params: InsertMutationFnParams<ResolvedType, TKey, LocalOnlyCollectionUtils>
+    params: InsertMutationFnParams<TItem, TKey, LocalOnlyCollectionUtils>
   ) => {
     // Call user handler first if provided
     let handlerResult
     if (onInsert) {
-      handlerResult = (await onInsert(params)) ?? {}
+      handlerResult =
+        (await (
+          onInsert as (
+            p: InsertMutationFnParams<
+              TInsertInput,
+              TKey,
+              LocalOnlyCollectionUtils
+            >
+          ) => Promise<any>
+        )(
+          params as unknown as InsertMutationFnParams<
+            TInsertInput,
+            TKey,
+            LocalOnlyCollectionUtils
+          >
+        )) ?? {}
     }
 
     // Then synchronously confirm the transaction by looping through mutations
@@ -175,7 +199,7 @@ export function localOnlyCollectionOptions<
    * Wrapper for onUpdate handler that also confirms the transaction immediately
    */
   const wrappedOnUpdate = async (
-    params: UpdateMutationFnParams<ResolvedType, TKey, LocalOnlyCollectionUtils>
+    params: UpdateMutationFnParams<TItem, TKey, LocalOnlyCollectionUtils>
   ) => {
     // Call user handler first if provided
     let handlerResult
@@ -193,7 +217,7 @@ export function localOnlyCollectionOptions<
    * Wrapper for onDelete handler that also confirms the transaction immediately
    */
   const wrappedOnDelete = async (
-    params: DeleteMutationFnParams<ResolvedType, TKey, LocalOnlyCollectionUtils>
+    params: DeleteMutationFnParams<TItem, TKey, LocalOnlyCollectionUtils>
   ) => {
     // Call user handler first if provided
     let handlerResult
diff --git a/packages/db/src/local-storage.ts b/packages/db/src/local-storage.ts
index 43dfc5af..c1e63818 100644
--- a/packages/db/src/local-storage.ts
+++ b/packages/db/src/local-storage.ts
@@ -9,7 +9,9 @@ import {
 import type {
   CollectionConfig,
   DeleteMutationFnParams,
+  InsertMutationFn,
   InsertMutationFnParams,
+  ResolveInsertInput,
   ResolveType,
   SyncConfig,
   UpdateMutationFnParams,
@@ -62,6 +64,7 @@ export interface LocalStorageCollectionConfig<
   TExplicit = unknown,
   TSchema extends StandardSchemaV1 = never,
   TFallback extends object = Record<string, unknown>,
+  TKey extends string | number = string | number,
 > {
   /**
    * The key to use for storing the collection data in localStorage/sessionStorage
@@ -85,8 +88,18 @@ export interface LocalStorageCollectionConfig<
    */
   id?: string
   schema?: TSchema
-  getKey: CollectionConfig<ResolveType<TExplicit, TSchema, TFallback>>[`getKey`]
-  sync?: CollectionConfig<ResolveType<TExplicit, TSchema, TFallback>>[`sync`]
+  getKey: CollectionConfig<
+    ResolveType<TExplicit, TSchema, TFallback>,
+    TKey,
+    TSchema,
+    ResolveInsertInput<TExplicit, TSchema, TFallback>
+  >[`getKey`]
+  sync?: CollectionConfig<
+    ResolveType<TExplicit, TSchema, TFallback>,
+    TKey,
+    TSchema,
+    ResolveInsertInput<TExplicit, TSchema, TFallback>
+  >[`sync`]
 
   /**
    * Optional asynchronous handler function called before an insert operation
@@ -94,7 +107,10 @@ export interface LocalStorageCollectionConfig<
    * @returns Promise resolving to any value
    */
   onInsert?: (
-    params: InsertMutationFnParams<ResolveType<TExplicit, TSchema, TFallback>>
+    params: InsertMutationFnParams<
+      ResolveInsertInput<TExplicit, TSchema, TFallback>,
+      TKey
+    >
   ) => Promise<any>
 
   /**
@@ -103,7 +119,10 @@ export interface LocalStorageCollectionConfig<
    * @returns Promise resolving to any value
    */
   onUpdate?: (
-    params: UpdateMutationFnParams<ResolveType<TExplicit, TSchema, TFallback>>
+    params: UpdateMutationFnParams<
+      ResolveType<TExplicit, TSchema, TFallback>,
+      TKey
+    >
   ) => Promise<any>
 
   /**
@@ -112,7 +131,10 @@ export interface LocalStorageCollectionConfig<
    * @returns Promise resolving to any value
    */
   onDelete?: (
-    params: DeleteMutationFnParams<ResolveType<TExplicit, TSchema, TFallback>>
+    params: DeleteMutationFnParams<
+      ResolveType<TExplicit, TSchema, TFallback>,
+      TKey
+    >
   ) => Promise<any>
 }
 
@@ -206,13 +228,23 @@ export function localStorageCollectionOptions<
   TExplicit = unknown,
   TSchema extends StandardSchemaV1 = never,
   TFallback extends object = Record<string, unknown>,
+  TKey extends string | number = string | number,
 >(
-  config: LocalStorageCollectionConfig<TExplicit, TSchema, TFallback>
-): Omit<CollectionConfig<ResolveType<TExplicit, TSchema, TFallback>>, `id`> & {
+  config: LocalStorageCollectionConfig<TExplicit, TSchema, TFallback, TKey>
+): Omit<
+  CollectionConfig<
+    ResolveType<TExplicit, TSchema, TFallback>,
+    TKey,
+    TSchema,
+    ResolveInsertInput<TExplicit, TSchema, TFallback>
+  >,
+  `id`
+> & {
   id: string
   utils: LocalStorageCollectionUtils
 } {
-  type ResolvedType = ResolveType<TExplicit, TSchema, TFallback>
+  type TItem = ResolveType<TExplicit, TSchema, TFallback>
+  type TInsertInput = ResolveInsertInput<TExplicit, TSchema, TFallback>
 
   // Validate required parameters
   if (!config.storageKey) {
@@ -237,14 +269,14 @@ export function localStorageCollectionOptions<
   }
 
   // Track the last known state to detect changes
-  const lastKnownData = new Map<string | number, StoredItem<ResolvedType>>()
+  const lastKnownData = new Map<string | number, StoredItem<TItem>>()
 
   // Create the sync configuration
-  const sync = createLocalStorageSync<ResolvedType>(
+  const sync = createLocalStorageSync<TItem, TKey>(
     config.storageKey,
     storage,
     storageEventApi,
-    config.getKey,
+    config.getKey as (item: TItem) => TKey,
     lastKnownData
   )
 
@@ -263,11 +295,11 @@ export function localStorageCollectionOptions<
    * @param dataMap - Map of items with version tracking to save to storage
    */
   const saveToStorage = (
-    dataMap: Map<string | number, StoredItem<ResolvedType>>
+    dataMap: Map<string | number, StoredItem<TItem>>
   ): void => {
     try {
       // Convert Map to object format for storage
-      const objectData: Record<string, StoredItem<ResolvedType>> = {}
+      const objectData: Record<string, StoredItem<TItem>> = {}
       dataMap.forEach((storedItem, key) => {
         objectData[String(key)] = storedItem
       })
@@ -303,7 +335,7 @@ export function localStorageCollectionOptions<
    * Wraps the user's onInsert handler to also save changes to localStorage
    */
   const wrappedOnInsert = async (
-    params: InsertMutationFnParams<ResolvedType>
+    params: InsertMutationFnParams<TItem, TKey>
   ) => {
     // Validate that all values in the transaction can be JSON serialized
     params.transaction.mutations.forEach((mutation) => {
@@ -313,20 +345,20 @@ export function localStorageCollectionOptions<
     // Call the user handler BEFORE persisting changes (if provided)
     let handlerResult: any = {}
     if (config.onInsert) {
-      handlerResult = (await config.onInsert(params)) ?? {}
+      handlerResult =
+        (await (config.onInsert as InsertMutationFn<TInsertInput, TKey>)(
+          params as unknown as InsertMutationFnParams<TInsertInput, TKey>
+        )) ?? {}
     }
 
     // Always persist to storage
     // Load current data from storage
-    const currentData = loadFromStorage<ResolvedType>(
-      config.storageKey,
-      storage
-    )
+    const currentData = loadFromStorage<TItem>(config.storageKey, storage)
 
     // Add new items with version keys
     params.transaction.mutations.forEach((mutation) => {
-      const key = config.getKey(mutation.modified)
-      const storedItem: StoredItem<ResolvedType> = {
+      const key = (config.getKey as (item: TItem) => TKey)(mutation.modified)
+      const storedItem: StoredItem<TItem> = {
         versionKey: generateUuid(),
         data: mutation.modified,
       }
@@ -343,7 +375,7 @@ export function localStorageCollectionOptions<
   }
 
   const wrappedOnUpdate = async (
-    params: UpdateMutationFnParams<ResolvedType>
+    params: UpdateMutationFnParams<TItem, TKey>
   ) => {
     // Validate that all values in the transaction can be JSON serialized
     params.transaction.mutations.forEach((mutation) => {
@@ -358,15 +390,12 @@ export function localStorageCollectionOptions<
 
     // Always persist to storage
     // Load current data from storage
-    const currentData = loadFromStorage<ResolvedType>(
-      config.storageKey,
-      storage
-    )
+    const currentData = loadFromStorage<TItem>(config.storageKey, storage)
 
     // Update items with new version keys
     params.transaction.mutations.forEach((mutation) => {
-      const key = config.getKey(mutation.modified)
-      const storedItem: StoredItem<ResolvedType> = {
+      const key = (config.getKey as (item: TItem) => TKey)(mutation.modified)
+      const storedItem: StoredItem<TItem> = {
         versionKey: generateUuid(),
         data: mutation.modified,
       }
@@ -383,7 +412,7 @@ export function localStorageCollectionOptions<
   }
 
   const wrappedOnDelete = async (
-    params: DeleteMutationFnParams<ResolvedType>
+    params: DeleteMutationFnParams<TItem, TKey>
   ) => {
     // Call the user handler BEFORE persisting changes (if provided)
     let handlerResult: any = {}
@@ -393,15 +422,14 @@ export function localStorageCollectionOptions<
 
     // Always persist to storage
     // Load current data from storage
-    const currentData = loadFromStorage<ResolvedType>(
-      config.storageKey,
-      storage
-    )
+    const currentData = loadFromStorage<TItem>(config.storageKey, storage)
 
     // Remove items
     params.transaction.mutations.forEach((mutation) => {
       // For delete operations, mutation.original contains the full object
-      const key = config.getKey(mutation.original as ResolvedType)
+      const key = (config.getKey as (item: TItem) => TKey)(
+        mutation.original as TItem
+      )
       currentData.delete(key)
     })
 
@@ -433,7 +461,10 @@ export function localStorageCollectionOptions<
     ...restConfig,
     id: collectionId,
     sync,
-    onInsert: wrappedOnInsert,
+    onInsert: wrappedOnInsert as unknown as InsertMutationFn<
+      TInsertInput,
+      TKey
+    >,
     onUpdate: wrappedOnUpdate,
     onDelete: wrappedOnDelete,
     utils: {
@@ -506,14 +537,17 @@ function loadFromStorage<T extends object>(
  * @param lastKnownData - Map tracking the last known state for change detection
  * @returns Sync configuration with manual trigger capability
  */
-function createLocalStorageSync<T extends object>(
+function createLocalStorageSync<
+  T extends object,
+  TKey extends string | number = string | number,
+>(
   storageKey: string,
   storage: StorageApi,
   storageEventApi: StorageEventApi,
-  _getKey: (item: T) => string | number,
+  _getKey: (item: T) => TKey,
   lastKnownData: Map<string | number, StoredItem<T>>
-): SyncConfig<T> & { manualTrigger?: () => void } {
-  let syncParams: Parameters<SyncConfig<T>[`sync`]>[0] | null = null
+): SyncConfig<T, TKey> & { manualTrigger?: () => void } {
+  let syncParams: Parameters<SyncConfig<T, TKey>[`sync`]>[0] | null = null
 
   /**
    * Compare two Maps to find differences using version keys
@@ -588,8 +622,8 @@ function createLocalStorageSync<T extends object>(
     }
   }
 
-  const syncConfig: SyncConfig<T> & { manualTrigger?: () => void } = {
-    sync: (params: Parameters<SyncConfig<T>[`sync`]>[0]) => {
+  const syncConfig: SyncConfig<T, TKey> & { manualTrigger?: () => void } = {
+    sync: (params: Parameters<SyncConfig<T, TKey>[`sync`]>[0]) => {
       const { begin, write, commit, markReady } = params
 
       // Store sync params for later use
diff --git a/packages/db/tests/collection.test-d.ts b/packages/db/tests/collection.test-d.ts
index 0faa6834..01cca41a 100644
--- a/packages/db/tests/collection.test-d.ts
+++ b/packages/db/tests/collection.test-d.ts
@@ -2,7 +2,11 @@ import { assertType, describe, expectTypeOf, it } from "vitest"
 import { z } from "zod"
 import { createCollection } from "../src/collection"
 import type { CollectionImpl } from "../src/collection"
-import type { OperationConfig, ResolveType } from "../src/types"
+import type {
+  OperationConfig,
+  ResolveInsertInput,
+  ResolveType,
+} from "../src/types"
 import type { StandardSchemaV1 } from "@standard-schema/spec"
 
 describe(`Collection.update type tests`, () => {
@@ -195,3 +199,115 @@ describe(`Collection type resolution tests`, () => {
     expectTypeOf<ItemOf<Param>>().toEqualTypeOf<ExpectedType>()
   })
 })
+
+describe(`Schema Input/Output Type Distinction`, () => {
+  // Define schema with different input/output types
+  const userSchemaWithDefaults = z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string().email(),
+    created_at: z.date().default(() => new Date()),
+    updated_at: z.date().default(() => new Date()),
+  })
+
+  // Define schema with transformations
+  const userSchemaTransform = z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string().email(),
+    created_at: z.string().transform((val) => new Date(val)),
+    updated_at: z.string().transform((val) => new Date(val)),
+  })
+
+  it(`should handle schema with default values correctly`, () => {
+    const collection = createCollection({
+      getKey: (item) => item.id,
+      sync: { sync: () => {} },
+      schema: userSchemaWithDefaults,
+    })
+
+    type ExpectedOutputType = ResolveType<
+      unknown,
+      typeof userSchemaWithDefaults,
+      Record<string, unknown>
+    >
+    type ExpectedInputType = ResolveInsertInput<
+      unknown,
+      typeof userSchemaWithDefaults,
+      Record<string, unknown>
+    >
+    type InsertArg = Parameters<typeof collection.insert>[0]
+
+    // Input type should not include defaulted fields
+    expectTypeOf<ExpectedInputType>().toEqualTypeOf<{
+      id: string
+      name: string
+      email: string
+      created_at?: Date
+      updated_at?: Date
+    }>()
+
+    // Output type should include all fields
+    expectTypeOf<ExpectedOutputType>().toEqualTypeOf<{
+      id: string
+      name: string
+      email: string
+      created_at: Date
+      updated_at: Date
+    }>()
+
+    // Insert should accept ExpectedInputType or array thereof
+    expectTypeOf<InsertArg>().toEqualTypeOf<
+      ExpectedInputType | Array<ExpectedInputType>
+    >()
+
+    // Collection items should be ExpectedOutputType
+    expectTypeOf(collection.toArray).toEqualTypeOf<Array<ExpectedOutputType>>()
+  })
+
+  it(`should handle schema with transformations correctly`, () => {
+    const collection = createCollection({
+      getKey: (item) => item.id,
+      sync: { sync: () => {} },
+      schema: userSchemaTransform,
+    })
+
+    type ExpectedInputType = ResolveInsertInput<
+      unknown,
+      typeof userSchemaTransform,
+      Record<string, unknown>
+    >
+    type ExpectedOutputType = ResolveType<
+      unknown,
+      typeof userSchemaTransform,
+      Record<string, unknown>
+    >
+    type InsertArg = Parameters<typeof collection.insert>[0]
+
+    // Input type should be the raw input (before transformation)
+    expectTypeOf<ExpectedInputType>().toEqualTypeOf<{
+      id: string
+      name: string
+      email: string
+      created_at: string
+      updated_at: string
+    }>()
+
+    // Output type should be the transformed output
+    expectTypeOf<ExpectedOutputType>().toEqualTypeOf<{
+      id: string
+      name: string
+      email: string
+      created_at: Date
+      updated_at: Date
+    }>()
+
+    // Insert should accept ExpectedInputType or array thereof
+    expectTypeOf<InsertArg>().toEqualTypeOf<
+      ExpectedInputType | Array<ExpectedInputType>
+    >()
+
+    // Collection items should be ExpectedOutputType
+    expectTypeOf(collection.toArray).toEqualTypeOf<Array<ExpectedOutputType>>()
+  })
+})
diff --git a/packages/electric-db-collection/src/electric.ts b/packages/electric-db-collection/src/electric.ts
index d80f46bc..1ddfbad1 100644
--- a/packages/electric-db-collection/src/electric.ts
+++ b/packages/electric-db-collection/src/electric.ts
@@ -286,7 +286,14 @@ export function electricCollectionOptions<
   TExplicit extends Row<unknown> = Row<unknown>,
   TSchema extends StandardSchemaV1 = never,
   TFallback extends Row<unknown> = Row<unknown>,
->(config: ElectricCollectionConfig<TExplicit, TSchema, TFallback>) {
+>(
+  config: ElectricCollectionConfig<TExplicit, TSchema, TFallback>
+): CollectionConfig<
+  ResolveType<TExplicit, TSchema, TFallback>,
+  string | number,
+  TSchema,
+  ResolveType<TExplicit, TSchema, TFallback>
+> & { utils: ElectricCollectionUtils } {
   const seenTxids = new Store<Set<Txid>>(new Set([]))
   const sync = createElectricSync<ResolveType<TExplicit, TSchema, TFallback>>(
     config.shapeOptions,
diff --git a/packages/query-db-collection/package.json b/packages/query-db-collection/package.json
index e886f0d2..38bf316a 100644
--- a/packages/query-db-collection/package.json
+++ b/packages/query-db-collection/package.json
@@ -3,7 +3,8 @@
   "description": "TanStack Query collection for TanStack DB",
   "version": "0.2.1",
   "dependencies": {
-    "@tanstack/db": "workspace:*"
+    "@tanstack/db": "workspace:*",
+    "@standard-schema/spec": "^1.0.0"
   },
   "devDependencies": {
     "@tanstack/query-core": "^5.0.5",
diff --git a/packages/query-db-collection/src/query.ts b/packages/query-db-collection/src/query.ts
index 1a3074fc..3c1d165d 100644
--- a/packages/query-db-collection/src/query.ts
+++ b/packages/query-db-collection/src/query.ts
@@ -19,11 +19,14 @@ import type {
   DeleteMutationFnParams,
   InsertMutationFn,
   InsertMutationFnParams,
+  ResolveInsertInput,
+  ResolveType,
   SyncConfig,
   UpdateMutationFn,
   UpdateMutationFnParams,
   UtilsRecord,
 } from "@tanstack/db"
+import type { StandardSchemaV1 } from "@standard-schema/spec"
 
 // Re-export for external use
 export type { SyncOperation } from "./manual-sync"
@@ -35,14 +38,19 @@ export type { SyncOperation } from "./manual-sync"
  * @template TQueryKey - The type of the query key
  */
 export interface QueryCollectionConfig<
-  TItem extends object,
+  TExplicit extends object = Record<string, unknown>,
+  TSchema extends StandardSchemaV1 = never,
+  TFallback extends object = Record<string, unknown>,
   TError = unknown,
   TQueryKey extends QueryKey = QueryKey,
+  TKey extends string | number = string | number,
 > {
   /** The query key used by TanStack Query to identify this query */
   queryKey: TQueryKey
   /** Function that fetches data from the server. Must return the complete collection state */
-  queryFn: (context: QueryFunctionContext<TQueryKey>) => Promise<Array<TItem>>
+  queryFn: (
+    context: QueryFunctionContext<TQueryKey>
+  ) => Promise<Array<ResolveType<TExplicit, TSchema, TFallback>>>
   /** The TanStack Query client instance */
   queryClient: QueryClient
 
@@ -50,31 +58,31 @@ export interface QueryCollectionConfig<
   /** Whether the query should automatically run (default: true) */
   enabled?: boolean
   refetchInterval?: QueryObserverOptions<
-    Array<TItem>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
     TError,
-    Array<TItem>,
-    Array<TItem>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
     TQueryKey
   >[`refetchInterval`]
   retry?: QueryObserverOptions<
-    Array<TItem>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
     TError,
-    Array<TItem>,
-    Array<TItem>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
     TQueryKey
   >[`retry`]
   retryDelay?: QueryObserverOptions<
-    Array<TItem>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
     TError,
-    Array<TItem>,
-    Array<TItem>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
     TQueryKey
   >[`retryDelay`]
   staleTime?: QueryObserverOptions<
-    Array<TItem>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
     TError,
-    Array<TItem>,
-    Array<TItem>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
+    Array<ResolveType<TExplicit, TSchema, TFallback>>,
     TQueryKey
   >[`staleTime`]
 
@@ -82,11 +90,16 @@ export interface QueryCollectionConfig<
   /** Unique identifier for the collection */
   id?: string
   /** Function to extract the unique key from an item */
-  getKey: CollectionConfig<TItem>[`getKey`]
+  getKey: CollectionConfig<
+    ResolveType<TExplicit, TSchema, TFallback>,
+    TKey
+  >[`getKey`]
   /** Schema for validating items */
-  schema?: CollectionConfig<TItem>[`schema`]
-  sync?: CollectionConfig<TItem>[`sync`]
-  startSync?: CollectionConfig<TItem>[`startSync`]
+  schema?: TSchema
+  sync?: CollectionConfig<ResolveType<TExplicit, TSchema, TFallback>>[`sync`]
+  startSync?: CollectionConfig<
+    ResolveType<TExplicit, TSchema, TFallback>
+  >[`startSync`]
 
   // Direct persistence handlers
   /**
@@ -129,7 +142,10 @@ export interface QueryCollectionConfig<
    *   }
    * }
    */
-  onInsert?: InsertMutationFn<TItem>
+  onInsert?: InsertMutationFn<
+    ResolveInsertInput<TExplicit, TSchema, TFallback>,
+    TKey
+  >
 
   /**
    * Optional asynchronous handler function called before an update operation
@@ -182,7 +198,7 @@ export interface QueryCollectionConfig<
    *   return { refetch: false } // Skip automatic refetch since we handled it manually
    * }
    */
-  onUpdate?: UpdateMutationFn<TItem>
+  onUpdate?: UpdateMutationFn<ResolveType<TExplicit, TSchema, TFallback>, TKey>
 
   /**
    * Optional asynchronous handler function called before a delete operation
@@ -228,7 +244,7 @@ export interface QueryCollectionConfig<
    *   return { refetch: false } // Skip automatic refetch since we handled it manually
    * }
    */
-  onDelete?: DeleteMutationFn<TItem>
+  onDelete?: DeleteMutationFn<ResolveType<TExplicit, TSchema, TFallback>, TKey>
   // TODO type returning { refetch: boolean }
 
   /**
@@ -324,16 +340,35 @@ export interface QueryCollectionUtils<
  * )
  */
 export function queryCollectionOptions<
-  TItem extends object,
+  TExplicit extends object = Record<string, unknown>,
+  TSchema extends StandardSchemaV1 = never,
+  TFallback extends object = Record<string, unknown>,
   TError = unknown,
   TQueryKey extends QueryKey = QueryKey,
   TKey extends string | number = string | number,
-  TInsertInput extends object = TItem,
 >(
-  config: QueryCollectionConfig<TItem, TError, TQueryKey>
-): CollectionConfig<TItem> & {
-  utils: QueryCollectionUtils<TItem, TKey, TInsertInput>
+  config: QueryCollectionConfig<
+    TExplicit,
+    TSchema,
+    TFallback,
+    TError,
+    TQueryKey,
+    TKey
+  >
+): CollectionConfig<
+  ResolveType<TExplicit, TSchema, TFallback>,
+  TKey,
+  TSchema,
+  ResolveInsertInput<TExplicit, TSchema, TFallback>
+> & {
+  utils: QueryCollectionUtils<
+    ResolveType<TExplicit, TSchema, TFallback>,
+    TKey,
+    ResolveInsertInput<TExplicit, TSchema, TFallback>
+  >
 } {
+  type TItem = ResolveType<TExplicit, TSchema, TFallback>
+  type TInsertInput = ResolveInsertInput<TExplicit, TSchema, TFallback>
   const {
     queryKey,
     queryFn,
@@ -372,7 +407,7 @@ export function queryCollectionOptions<
     throw new GetKeyRequiredError()
   }
 
-  const internalSync: SyncConfig<TItem>[`sync`] = (params) => {
+  const internalSync: SyncConfig<TItem, TKey>[`sync`] = (params) => {
     const { begin, write, commit, markReady, collection } = params
 
     const observerOptions: QueryObserverOptions<
@@ -418,7 +453,7 @@ export function queryCollectionOptions<
         }
 
         const currentSyncedItems = new Map(collection.syncedData)
-        const newItemsMap = new Map<string | number, TItem>()
+        const newItemsMap = new Map<TKey, TItem>()
         newItemsArray.forEach((item) => {
           const key = getKey(item)
           newItemsMap.set(key, item)
@@ -512,12 +547,12 @@ export function queryCollectionOptions<
     queryKey: Array<unknown>
     getKey: (item: TItem) => TKey
     begin: () => void
-    write: (message: Omit<ChangeMessage<TItem>, `key`>) => void
+    write: (message: Omit<ChangeMessage<TItem, TKey>, `key`>) => void
     commit: () => void
   } | null = null
 
   // Enhanced internalSync that captures write functions for manual use
-  const enhancedInternalSync: SyncConfig<TItem>[`sync`] = (params) => {
+  const enhancedInternalSync: SyncConfig<TItem, TKey>[`sync`] = (params) => {
     const { begin, write, commit, collection } = params
 
     // Store references for manual write operations
@@ -542,7 +577,7 @@ export function queryCollectionOptions<
 
   // Create wrapper handlers for direct persistence operations that handle refetching
   const wrappedOnInsert = onInsert
-    ? async (params: InsertMutationFnParams<TItem>) => {
+    ? async (params: InsertMutationFnParams<TInsertInput, TKey>) => {
         const handlerResult = (await onInsert(params)) ?? {}
         const shouldRefetch =
           (handlerResult as { refetch?: boolean }).refetch !== false
@@ -556,7 +591,7 @@ export function queryCollectionOptions<
     : undefined
 
   const wrappedOnUpdate = onUpdate
-    ? async (params: UpdateMutationFnParams<TItem>) => {
+    ? async (params: UpdateMutationFnParams<TItem, TKey>) => {
         const handlerResult = (await onUpdate(params)) ?? {}
         const shouldRefetch =
           (handlerResult as { refetch?: boolean }).refetch !== false
@@ -570,7 +605,7 @@ export function queryCollectionOptions<
     : undefined
 
   const wrappedOnDelete = onDelete
-    ? async (params: DeleteMutationFnParams<TItem>) => {
+    ? async (params: DeleteMutationFnParams<TItem, TKey>) => {
         const handlerResult = (await onDelete(params)) ?? {}
         const shouldRefetch =
           (handlerResult as { refetch?: boolean }).refetch !== false
diff --git a/packages/query-db-collection/tests/query.test-d.ts b/packages/query-db-collection/tests/query.test-d.ts
index eb5d09db..18819bb9 100644
--- a/packages/query-db-collection/tests/query.test-d.ts
+++ b/packages/query-db-collection/tests/query.test-d.ts
@@ -186,4 +186,33 @@ describe(`Query collection type resolution tests`, () => {
     // Test that the getKey function has the correct parameter type
     expectTypeOf(queryOptions.getKey).parameters.toEqualTypeOf<[UserType]>()
   })
+  it(`types getKey param as schema OUTPUT and onInsert as schema INPUT`, () => {
+    const schema = z.object({
+      id: z.string(),
+      created_at: z.string().transform((s) => new Date(s)),
+      updated_at: z.string().transform((s) => new Date(s)),
+    })
+
+    type Output = z.output<typeof schema>
+    type Input = z.input<typeof schema>
+
+    const queryClient = new QueryClient()
+
+    const options = queryCollectionOptions({
+      queryClient,
+      queryKey: [`users`],
+      queryFn: () => Promise.resolve([] as Array<any>),
+      schema,
+      getKey: (item) => item.id,
+      onInsert: async () => {},
+      onUpdate: async () => {},
+    })
+
+    expectTypeOf(options.getKey).parameters.toEqualTypeOf<[Output]>()
+    // utils.writeInsert should accept schema INPUT
+    type WriteInsertParam0 = Parameters<
+      (typeof options.utils)[`writeInsert`]
+    >[0]
+    expectTypeOf<WriteInsertParam0>().toEqualTypeOf<Input | Array<Input>>()
+  })
 })
diff --git a/packages/trailbase-db-collection/src/trailbase.ts b/packages/trailbase-db-collection/src/trailbase.ts
index 88519ec1..a9c9f66e 100644
--- a/packages/trailbase-db-collection/src/trailbase.ts
+++ b/packages/trailbase-db-collection/src/trailbase.ts
@@ -84,11 +84,11 @@ function convertPartial<
  * Configuration interface for Trailbase Collection
  */
 export interface TrailBaseCollectionConfig<
-  TItem extends ShapeOf<TRecord>,
-  TRecord extends ShapeOf<TItem> = TItem,
+  TExplicit extends ShapeOf<TRecord>,
+  TRecord extends ShapeOf<TExplicit> = TExplicit,
   TKey extends string | number = string | number,
 > extends Omit<
-    CollectionConfig<TItem, TKey>,
+    CollectionConfig<TExplicit, TKey>,
     `sync` | `onInsert` | `onUpdate` | `onDelete`
   > {
   /**
@@ -96,8 +96,8 @@ export interface TrailBaseCollectionConfig<
    */
   recordApi: RecordApi<TRecord>
 
-  parse: Conversions<TRecord, TItem>
-  serialize: Conversions<TItem, TRecord>
+  parse: Conversions<TRecord, TExplicit>
+  serialize: Conversions<TExplicit, TRecord>
 }
 
 export type AwaitTxIdFn = (txId: string, timeout?: number) => Promise<boolean>
@@ -107,20 +107,20 @@ export interface TrailBaseCollectionUtils extends UtilsRecord {
 }
 
 export function trailBaseCollectionOptions<
-  TItem extends ShapeOf<TRecord>,
-  TRecord extends ShapeOf<TItem> = TItem,
+  TExplicit extends ShapeOf<TRecord>,
+  TRecord extends ShapeOf<TExplicit> = TExplicit,
   TKey extends string | number = string | number,
 >(
-  config: TrailBaseCollectionConfig<TItem, TRecord, TKey>
-): CollectionConfig<TItem, TKey> & { utils: TrailBaseCollectionUtils } {
+  config: TrailBaseCollectionConfig<TExplicit, TRecord, TKey>
+): CollectionConfig<TExplicit, TKey> & { utils: TrailBaseCollectionUtils } {
   const getKey = config.getKey
 
   const parse = (record: TRecord) =>
-    convert<TRecord, TItem>(config.parse, record)
-  const serialUpd = (item: Partial<TItem>) =>
-    convertPartial<TItem, TRecord>(config.serialize, item)
-  const serialIns = (item: TItem) =>
-    convert<TItem, TRecord>(config.serialize, item)
+    convert<TRecord, TExplicit>(config.parse, record)
+  const serialUpd = (item: Partial<TExplicit>) =>
+    convertPartial<TExplicit, TRecord>(config.serialize, item)
+  const serialIns = (item: TExplicit) =>
+    convert<TExplicit, TRecord>(config.serialize, item)
 
   const seenIds = new Store(new Map<string, number>())
 
@@ -159,7 +159,7 @@ export function trailBaseCollectionOptions<
     }
   }
 
-  type SyncParams = Parameters<SyncConfig<TItem, TKey>[`sync`]>[0]
+  type SyncParams = Parameters<SyncConfig<TExplicit, TKey>[`sync`]>[0]
   const sync = {
     sync: (params: SyncParams) => {
       const { begin, write, commit, markReady } = params
@@ -216,7 +216,7 @@ export function trailBaseCollectionOptions<
           }
 
           begin()
-          let value: TItem | undefined
+          let value: TExplicit | undefined
           if (`Insert` in event) {
             value = parse(event.Insert as TRecord)
             write({ type: `insert`, value })
@@ -294,7 +294,7 @@ export function trailBaseCollectionOptions<
     sync,
     getKey,
     onInsert: async (
-      params: InsertMutationFnParams<TItem, TKey>
+      params: InsertMutationFnParams<TExplicit, TKey>
     ): Promise<Array<number | string>> => {
       const ids = await config.recordApi.createBulk(
         params.transaction.mutations.map((tx) => {
@@ -313,7 +313,7 @@ export function trailBaseCollectionOptions<
 
       return ids
     },
-    onUpdate: async (params: UpdateMutationFnParams<TItem, TKey>) => {
+    onUpdate: async (params: UpdateMutationFnParams<TExplicit, TKey>) => {
       const ids: Array<string> = await Promise.all(
         params.transaction.mutations.map(async (tx) => {
           const { type, changes, key } = tx
@@ -332,7 +332,7 @@ export function trailBaseCollectionOptions<
       // DB by the subscription.
       await awaitIds(ids)
     },
-    onDelete: async (params: DeleteMutationFnParams<TItem, TKey>) => {
+    onDelete: async (params: DeleteMutationFnParams<TExplicit, TKey>) => {
       const ids: Array<string> = await Promise.all(
         params.transaction.mutations.map(async (tx) => {
           const { type, key } = tx
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b0ea21e2..d6af0bd6 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -539,6 +539,9 @@ importers:
 
   packages/query-db-collection:
     dependencies:
+      '@standard-schema/spec':
+        specifier: ^1.0.0
+        version: 1.0.0
       '@tanstack/db':
         specifier: workspace:*
         version: link:../db