diff --git a/docs-app/public/docs/1-get-started/typescript-and-glint.md b/docs-app/public/docs/1-get-started/typescript-and-glint.md
index 667c4045..98272e19 100644
--- a/docs-app/public/docs/1-get-started/typescript-and-glint.md
+++ b/docs-app/public/docs/1-get-started/typescript-and-glint.md
@@ -71,6 +71,88 @@ class Demo {
 }
 ```
 
+## Type-Safe Cell Components and Options
+
+The table library supports generic type parameters for strongly-typed Cell components and custom options. This enables full type inference in Glint templates and prevents common errors.
+
+### Basic Usage
+
+By default, all generic parameters are set to `any` for backward compatibility:
+
+```ts
+const table = headlessTable<MyDataType>(this, {
+  columns: () => [...],
+  data: () => myData
+});
+```
+
+### Advanced: Type-Safe Options
+
+To get type safety for custom options passed to cells:
+
+```ts
+import {
+  headlessTable,
+  type ColumnConfig,
+  type CellContext,
+} from "@universal-ember/table";
+
+interface MyData {
+  id: string;
+  name: string;
+}
+
+interface MyOptions {
+  highlightColor?: string;
+  showBadge?: boolean;
+}
+
+interface MyCellArgs extends CellContext<MyData, MyOptions> {
+  // Cell components receive data, column, row, and options
+}
+
+const table = headlessTable<MyData, MyOptions, MyCellArgs>(this, {
+  columns: () => [
+    {
+      key: "name",
+      name: "Name",
+      Cell: MyCustomCell, // fully typed!
+      options: ({ row }) => ({
+        highlightColor: row.data.id === "special" ? "blue" : "gray",
+        showBadge: true,
+      }),
+    },
+  ],
+  data: () => myData,
+});
+```
+
+Your Cell component will now have full type inference:
+
+```ts
+import Component from '@glimmer/component';
+
+class MyCustomCell extends Component<MyCellArgs> {
+  get color() {
+    return this.args.options?.highlightColor ?? 'gray';
+  }
+
+  <template>
+    <span style="color: {{this.color}}">
+      {{@row.data.name}}
+      {{#if @options.showBadge}}<span class="badge">!</span>{{/if}}
+    </span>
+  </template>
+}
+```
+
+### CellContext Types
+
+The library provides two context types:
+
+- **`CellConfigContext<T, OptionsType>`**: Used when defining column configurations. Has optional fields (`column?`, `row?`, `options?`) for user convenience.
+- **`CellContext<T, OptionsType>`**: Used for Cell component signatures. Has required fields since they're always provided at runtime.
+
 ## In Templates
 
 [Glint][docs-glint] can be a great choice to help ensure that your code is as bug-free as possible.
diff --git a/table/src/-private/column.ts b/table/src/-private/column.ts
index c2dc5fb4..7b5cefc6 100644
--- a/table/src/-private/column.ts
+++ b/table/src/-private/column.ts
@@ -4,7 +4,11 @@ import { isEmpty } from '@ember/utils';
 import type { Row } from './row';
 import type { Table } from './table';
 import type { ContentValue } from '@glint/template';
-import type { ColumnConfig } from './interfaces';
+import type {
+  ColumnConfig,
+  CellOptions,
+  CellConfigContext,
+} from './interfaces';
 
 const DEFAULT_VALUE = '--';
 const DEFAULT_VALUE_KEY = 'defaultValue';
@@ -12,7 +16,7 @@ const DEFAULT_OPTIONS = {
   [DEFAULT_VALUE_KEY]: DEFAULT_VALUE,
 };
 
-export class Column<T = unknown> {
+export class Column<T = unknown, OptionsType = any, CellArgs = any> {
   get Cell() {
     return this.config.Cell;
   }
@@ -27,7 +31,7 @@ export class Column<T = unknown> {
 
   constructor(
     public table: Table<T>,
-    public config: ColumnConfig<T>,
+    public config: ColumnConfig<T, OptionsType, CellArgs>,
   ) {}
 
   @action
@@ -52,11 +56,12 @@ export class Column<T = unknown> {
   }
 
   private getDefaultValue(row: Row<T>) {
-    return this.getOptionsForRow(row)[DEFAULT_VALUE_KEY];
+    const options = this.getOptionsForRow(row) as any;
+    return options[DEFAULT_VALUE_KEY];
   }
 
   @action
-  getOptionsForRow(row: Row<T>) {
+  getOptionsForRow(row?: Row<T>): OptionsType & CellOptions {
     const configuredDefault = this.table.config.defaultCellValue;
     const defaults = {
       [DEFAULT_VALUE_KEY]:
@@ -66,6 +71,6 @@ export class Column<T = unknown> {
     return {
       ...defaults,
       ...this.config.options?.({ column: this, row }),
-    };
+    } as OptionsType & CellOptions;
   }
 }
diff --git a/table/src/-private/interfaces/column.ts b/table/src/-private/interfaces/column.ts
index 7b893d0a..6da940ae 100644
--- a/table/src/-private/interfaces/column.ts
+++ b/table/src/-private/interfaces/column.ts
@@ -5,9 +5,18 @@ import type { ColumnOptionsFor, SignatureFrom } from './plugins';
 import type { Constructor } from '../private-types';
 import type { ComponentLike, ContentValue } from '@glint/template';
 
-export interface CellContext<T> {
-  column: Column<T>;
-  row: Row<T>;
+// Configuration context (for defining column options) - optional fields for user convenience
+export interface CellConfigContext<DataType = unknown, OptionsType = unknown> {
+  column?: Column<DataType, OptionsType>;
+  row?: Row<DataType>;
+  options?: OptionsType & CellOptions;
+}
+
+// Runtime context (for Cell components) - required fields since they're always provided
+export interface CellContext<DataType, OptionsType = unknown> {
+  column: Column<DataType, OptionsType>;
+  row: Row<DataType>;
+  options?: OptionsType & CellOptions;
 }
 
 type ColumnPluginOption<P = Plugin> = P extends BasePlugin
@@ -21,7 +30,11 @@ export type CellOptions = {
   defaultValue?: string;
 } & Record<string, unknown>;
 
-export interface ColumnConfig<T = unknown> {
+export interface ColumnConfig<
+  DataType = unknown,
+  OptionsType = unknown,
+  CellArgs = unknown,
+> {
   /**
    * the `key` is required for preferences storage, as well as
    * managing uniqueness of the columns in an easy-to-understand way.
@@ -37,14 +50,14 @@ export interface ColumnConfig<T = unknown> {
   /**
    * Optionally provide a function to determine the value of a row at this column
    */
-  value?: (context: CellContext<T>) => ContentValue;
+  value?(context: CellConfigContext<DataType>): ContentValue;
 
   /**
    * Recommended property to use for custom components for each cell per column.
    * Out-of-the-box, this property isn't used, but the provided type may be
    * a convenience for consumers of the headless table
    */
-  Cell?: ComponentLike<CellContext<T>>;
+  Cell?: ComponentLike<CellArgs>;
 
   /**
    * The name or title of the column, shown in the column heading / th
@@ -54,7 +67,7 @@ export interface ColumnConfig<T = unknown> {
   /**
    * Bag of extra properties to pass to Cell via `@options`, if desired
    */
-  options?: (context: CellContext<T>) => CellOptions;
+  options?(context: CellConfigContext<DataType>): OptionsType;
 
   /**
    * Each plugin may provide column options, and provides similar syntax to how
@@ -70,4 +83,4 @@ export interface ColumnConfig<T = unknown> {
   pluginOptions?: ColumnPluginOption[];
 }
 
-export type ColumnKey<T> = NonNullable<ColumnConfig<T>['key']>;
+export type ColumnKey<DataType> = NonNullable<ColumnConfig<DataType>['key']>;
diff --git a/table/src/-private/interfaces/table.ts b/table/src/-private/interfaces/table.ts
index 1900129b..f305e489 100644
--- a/table/src/-private/interfaces/table.ts
+++ b/table/src/-private/interfaces/table.ts
@@ -1,5 +1,5 @@
 import type { Plugins } from '../../plugins/-private/utils';
-import type { ColumnConfig } from './column';
+import type { ColumnConfig, CellOptions, CellContext } from './column';
 import type { Pagination } from './pagination';
 import type { PreferencesAdapter } from './preferences';
 import type { Selection } from './selection';
@@ -9,13 +9,13 @@ export interface TableMeta {
   totalRowsSelectedCount?: number;
 }
 
-export interface TableConfig<DataType> {
+export interface TableConfig<DataType, OptionsType = any, CellArgs = any> {
   /**
    * Configuration describing how the table will crawl through `data`
    * and render it. Within this `columns` config, there will also be opportunities
    * to set the behavior of columns when rendered
    */
-  columns: () => ColumnConfig<DataType>[];
+  columns: () => ColumnConfig<DataType, OptionsType, CellArgs>[];
   /**
    * The data to render, as described via the `columns` option.
    *
diff --git a/table/src/-private/js-helper.ts b/table/src/-private/js-helper.ts
index ebc3de96..03f9db67 100644
--- a/table/src/-private/js-helper.ts
+++ b/table/src/-private/js-helper.ts
@@ -1,10 +1,10 @@
 import { Table } from './table.ts';
 
-import type { TableConfig } from './interfaces';
+import type { TableConfig, CellContext } from './interfaces';
 
-type Args<T> =
-  | [destroyable: object, options: TableConfig<T>]
-  | [options: TableConfig<T>];
+type Args<DataType, OptionsType = any, CellArgs = any> =
+  | [destroyable: object, options: TableConfig<DataType, OptionsType, CellArgs>]
+  | [options: TableConfig<DataType, OptionsType, CellArgs>];
 
 /**
  * Represents a UI-less version of a table
@@ -23,7 +23,9 @@ type Args<T> =
  * }
  * ```
  */
-export function headlessTable<T = unknown>(options: TableConfig<T>): Table<T>;
+export function headlessTable<DataType = unknown, OptionsType = any, CellArgs = any>(
+  options: TableConfig<DataType, OptionsType, CellArgs>,
+): Table<DataType, OptionsType, CellArgs>;
 
 /**
  * Represents a UI-less version of a table
@@ -42,12 +44,14 @@ export function headlessTable<T = unknown>(options: TableConfig<T>): Table<T>;
  * ```
  *
  */
-export function headlessTable<T = unknown>(
+export function headlessTable<DataType = unknown, OptionsType = any, CellArgs = any>(
   destroyable: object,
-  options: TableConfig<T>,
-): Table<T>;
+  options: TableConfig<DataType, OptionsType, CellArgs>,
+): Table<DataType, OptionsType, CellArgs>;
 
-export function headlessTable<T = unknown>(...args: Args<T>): Table<T> {
+export function headlessTable<DataType = unknown, OptionsType = any, CellArgs = any>(
+  ...args: Args<DataType, OptionsType, CellArgs>
+): Table<DataType, OptionsType, CellArgs> {
   if (args.length === 2) {
     const [destroyable, options] = args;
 
@@ -56,10 +60,13 @@ export function headlessTable<T = unknown>(...args: Args<T>): Table<T> {
      * otherwise individual-property reactivity can be managed on a per-property
      * "thunk"-basis
      */
-    return Table.from<Table<T>>(destroyable, () => options);
+    return Table.from<Table<DataType, OptionsType, CellArgs>>(
+      destroyable,
+      () => options,
+    );
   }
 
   const [options] = args;
 
-  return Table.from<Table<T>>(() => options);
+  return Table.from<Table<DataType, OptionsType, CellArgs>>(() => options);
 }
diff --git a/table/src/-private/table.ts b/table/src/-private/table.ts
index 34e6205d..d0f9215b 100644
--- a/table/src/-private/table.ts
+++ b/table/src/-private/table.ts
@@ -20,6 +20,7 @@ import { composeFunctionModifiers } from './utils.ts';
 import type { BasePlugin, Plugin } from '../plugins/index.ts';
 import type { Class } from './private-types.ts';
 import type { Destructor, TableConfig } from './interfaces';
+import type { CellOptions, CellContext } from './interfaces/column.ts';
 import { compatOwner } from './ember-compat.ts';
 
 const getOwner = compatOwner.getOwner;
@@ -30,8 +31,8 @@ const DEFAULT_COLUMN_CONFIG = {
   minWidth: 128,
 };
 
-interface Signature<DataType> {
-  Named: TableConfig<DataType>;
+interface Signature<DataType, OptionsType = any, CellArgs = any> {
+  Named: TableConfig<DataType, OptionsType>;
 }
 
 /**
@@ -54,7 +55,11 @@ const attachContainer = (element: Element, table: Table) => {
   table.scrollContainerElement = element;
 };
 
-export class Table<DataType = unknown> extends Resource<Signature<DataType>> {
+export class Table<
+  DataType = unknown,
+  OptionsType = any,
+  CellArgs = any,
+> extends Resource<Signature<DataType, OptionsType, CellArgs>> {
   /**
    * @private
    */
@@ -66,11 +71,14 @@ export class Table<DataType = unknown> extends Resource<Signature<DataType>> {
   /**
    * @private
    */
-  [COLUMN_META_KEY] = new WeakMap<Column, Map<Class<unknown>, any>>();
+  [COLUMN_META_KEY] = new WeakMap<
+    Column<DataType, OptionsType, CellArgs>,
+    Map<Class<unknown>, any>
+  >();
   /**
    * @private
    */
-  [ROW_META_KEY] = new WeakMap<Row, Map<Class<unknown>, any>>();
+  [ROW_META_KEY] = new WeakMap<Row<DataType>, Map<Class<unknown>, any>>();
 
   /**
    * @private
@@ -110,7 +118,10 @@ export class Table<DataType = unknown> extends Resource<Signature<DataType>> {
   /**
    * @private
    */
-  modify(_: [] | undefined, named: Signature<DataType>['Named']) {
+  modify(
+    _: [] | undefined,
+    named: Signature<DataType, OptionsType, CellArgs>['Named'],
+  ) {
     this.args = { named };
 
     // only set the preferences once
@@ -157,7 +168,10 @@ export class Table<DataType = unknown> extends Resource<Signature<DataType>> {
     //       With curried+composed modifiers, only the plugin's headerModifier
     //       that has tracked changes would run, leaving the other modifiers alone
     columnHeader: modifier(
-      (element: HTMLElement, [column]: [Column<DataType>]): Destructor => {
+      (
+        element: HTMLElement,
+        [column]: [Column<DataType, OptionsType, CellArgs>],
+      ): Destructor => {
         const modifiers = this.plugins.map(
           (plugin) => plugin.headerCellModifier,
         );
@@ -251,7 +265,7 @@ export class Table<DataType = unknown> extends Resource<Signature<DataType>> {
 
       return dataFn() ?? [];
     },
-    map: (datum) => new Row(this, datum),
+    map: (datum) => new Row<DataType>(this, datum),
   });
 
   columns = map(this, {
@@ -286,7 +300,7 @@ export class Table<DataType = unknown> extends Resource<Signature<DataType>> {
       return result;
     },
     map: (config) => {
-      return new Column<DataType>(this, {
+      return new Column<DataType, OptionsType, CellArgs>(this, {
         ...DEFAULT_COLUMN_CONFIG,
         ...config,
       });
diff --git a/table/src/index.ts b/table/src/index.ts
index e4182017..7c5ba470 100644
--- a/table/src/index.ts
+++ b/table/src/index.ts
@@ -12,6 +12,7 @@ export { deserializeSorts, serializeSorts } from './utils.ts';
  *******************************/
 export type { Column } from './-private/column.ts';
 export type {
+  CellContext,
   ColumnConfig,
   ColumnKey,
   Pagination,
diff --git a/table/src/plugins/-private/base.ts b/table/src/plugins/-private/base.ts
index 8d673a63..73e6f258 100644
--- a/table/src/plugins/-private/base.ts
+++ b/table/src/plugins/-private/base.ts
@@ -296,10 +296,10 @@ export const preferences = {
  * This works recursively up the plugin tree up until a plugin has no requirements, and then
  * all columns from the table are returned.
  */
-function columnsFor<DataType = any>(
-  table: Table<DataType>,
+function columnsFor<DataType = any, OptionsType = any, CellArgs = any>(
+  table: Table<DataType, OptionsType, CellArgs>,
   requester?: Plugin<any>,
-): Column<DataType>[] {
+): Column<DataType, OptionsType, CellArgs>[] {
   assert(
     `First argument passed to columns.for must be an instance of Table`,
     table[TABLE_KEY],
@@ -417,10 +417,10 @@ export const columns = {
    * If a plugin class is provided, the hierarchy of column list modifications
    * will be respected.
    */
-  next: <Data = unknown>(
-    current: Column<Data>,
+  next: <Data = unknown, OptionsType = any>(
+    current: Column<Data, OptionsType>,
     requester?: Plugin<any>,
-  ): Column<Data> | undefined => {
+  ): Column<Data, OptionsType> | undefined => {
     const columns = requester
       ? columnsFor(current.table, requester)
       : columnsFor(current.table);
@@ -449,10 +449,10 @@ export const columns = {
    * If a plugin class is provided, the hierarchy of column list modifications
    * will be respected.
    */
-  previous: <Data = unknown>(
-    current: Column<Data>,
+  previous: <Data = unknown, OptionsType = any>(
+    current: Column<Data, OptionsType>,
     requester?: Plugin<any>,
-  ): Column<Data> | undefined => {
+  ): Column<Data, OptionsType> | undefined => {
     const columns = requester
       ? columnsFor(current.table, requester)
       : columnsFor(current.table);
@@ -479,10 +479,10 @@ export const columns = {
    * if a plugin class is provided, the hierarchy of column list modifications
    * will be respected.
    */
-  before: <Data = unknown>(
-    current: Column<Data>,
+  before: <Data = unknown, OptionsType = any>(
+    current: Column<Data, OptionsType>,
     requester?: Plugin<any>,
-  ): Column<Data>[] => {
+  ): Column<Data, OptionsType>[] => {
     const columns = requester
       ? columnsFor(current.table, requester)
       : columnsFor(current.table);
@@ -498,10 +498,10 @@ export const columns = {
    * if a plugin class is provided, the hierarchy of column list modifications
    * will be respected.
    */
-  after: <Data = unknown>(
-    current: Column<Data>,
+  after: <Data = unknown, OptionsType = any>(
+    current: Column<Data, OptionsType>,
     requester?: Plugin<any>,
-  ): Column<Data>[] => {
+  ): Column<Data, OptionsType>[] => {
     const columns = requester
       ? columnsFor(current.table, requester)
       : columnsFor(current.table);
@@ -767,7 +767,7 @@ function getPluginInstance<Instance>(
   factory: () => Instance,
 ): Instance;
 function getPluginInstance<RootKey extends Column<any> | Row<any>, Instance>(
-  map: WeakMap<Column | Row, Map<Class<Instance>, Instance>>,
+  map: WeakMap<Column<any> | Row<any>, Map<Class<Instance>, Instance>>,
   rootKey: RootKey,
   mapKey: Class<Instance>,
   factory: () => Instance,
@@ -776,13 +776,15 @@ function getPluginInstance<RootKey extends Column<any> | Row<any>, Instance>(
   ...args:
     | [FactoryMap<Instance>, Class<Instance>, () => Instance]
     | [
-        WeakMap<Column | Row, FactoryMap<Instance>>,
+        WeakMap<Column<any> | Row<any>, FactoryMap<Instance>>,
         RootKey,
         Class<Instance>,
         () => Instance,
       ]
 ): Instance {
-  let map: WeakMap<Column | Row, FactoryMap<Instance>> | FactoryMap<Instance>;
+  let map:
+    | WeakMap<Column<any> | Row<any>, FactoryMap<Instance>>
+    | FactoryMap<Instance>;
   let mapKey: Class<Instance>;
   let rootKey: RootKey | undefined;
   let factory: () => Instance;
diff --git a/table/src/plugins/column-reordering/plugin.ts b/table/src/plugins/column-reordering/plugin.ts
index 7a72fcba..7fb7ebdd 100644
--- a/table/src/plugins/column-reordering/plugin.ts
+++ b/table/src/plugins/column-reordering/plugin.ts
@@ -124,7 +124,7 @@ export class TableMeta {
    * Get the curret order/position of a column
    */
   @action
-  getPosition<DataType = unknown>(column: Column<DataType>) {
+  getPosition<DataType = unknown>(column: Column) {
     return this.columnOrder.get(column.key);
   }
 
@@ -132,10 +132,7 @@ export class TableMeta {
    * Swap the column with the column at `newPosition`
    */
   @action
-  setPosition<DataType = unknown>(
-    column: Column<DataType>,
-    newPosition: number,
-  ) {
+  setPosition<DataType = unknown>(column: Column, newPosition: number) {
     return this.columnOrder.swapWith(column.key, newPosition);
   }
 
@@ -507,7 +504,9 @@ export class ColumnOrder {
     );
     const mergedOrder = orderOf(allColumns, this.map);
 
-    const result: Column[] = Array.from({ length: allColumns.length });
+    const result: Column[] = Array.from({
+      length: allColumns.length,
+    });
 
     for (const [key, position] of mergedOrder.entries()) {
       const column = columnsByKey[key];
diff --git a/table/src/plugins/column-visibility/plugin.ts b/table/src/plugins/column-visibility/plugin.ts
index b8f3c37a..531effae 100644
--- a/table/src/plugins/column-visibility/plugin.ts
+++ b/table/src/plugins/column-visibility/plugin.ts
@@ -64,8 +64,8 @@ export class ColumnVisibility
   }
 }
 
-export class ColumnMeta<Data = unknown> {
-  constructor(private column: Column<Data>) {}
+export class ColumnMeta<DataType = unknown> {
+  constructor(private column: Column<DataType>) {}
 
   get isVisible(): boolean {
     const columnPreferences = preferences.forColumn(
@@ -132,11 +132,11 @@ export class ColumnMeta<Data = unknown> {
   };
 }
 
-export class TableMeta<Data = unknown> {
-  constructor(private table: Table<Data>) {}
+export class TableMeta<DataType = unknown> {
+  constructor(private table: Table<DataType>) {}
 
   @cached
-  get visibleColumns(): Column<Data>[] {
+  get visibleColumns(): Column<DataType>[] {
     const allColumns = this.table.columns.values();
 
     return allColumns.filter((column) => {
@@ -147,7 +147,7 @@ export class TableMeta<Data = unknown> {
   }
 
   @action
-  toggleColumnVisibility(column: Column<Data>) {
+  toggleColumnVisibility(column: Column<DataType>) {
     const columnMeta = meta.forColumn(column, ColumnVisibility);
 
     columnMeta.toggle();