diff --git a/src/Checkbox/Checkbox.svelte b/src/Checkbox/Checkbox.svelte
index f6fe1a9a07..2e8db7f604 100644
--- a/src/Checkbox/Checkbox.svelte
+++ b/src/Checkbox/Checkbox.svelte
@@ -1,21 +1,22 @@
 <script>
   /**
+   * @generics {T = any} T
    * @restProps {div}
    * @event {boolean} check
    */
 
   /**
    * Specify the value of the checkbox.
-   * @type {any}
+   * @type {T}
    */
-  export let value = "";
+  export let value = /** @type {T} */ ("");
 
   /** Specify whether the checkbox is checked */
   export let checked = false;
 
   /**
    * Specify the bound group.
-   * @type {ReadonlyArray<any>}
+   * @type {ReadonlyArray<T> | undefined}
    */
   export let group = undefined;
 
diff --git a/src/DataTable/ToolbarBatchActions.svelte b/src/DataTable/ToolbarBatchActions.svelte
index 213d54c4b7..1e1463a9e5 100644
--- a/src/DataTable/ToolbarBatchActions.svelte
+++ b/src/DataTable/ToolbarBatchActions.svelte
@@ -1,5 +1,6 @@
 <script>
   /**
+   * @generics {Id = any} Id
    * @event {null} cancel
    */
 
@@ -19,7 +20,7 @@
   /**
    * Specify the selected IDs for standalone usage.
    * This is unnecessary if using this component with `DataTable`.
-   * @type {ReadonlyArray<any>}
+   * @type {ReadonlyArray<Id>}
    */
   export let selectedIds = [];
 
diff --git a/src/LocalStorage/LocalStorage.svelte b/src/LocalStorage/LocalStorage.svelte
index 98d9d56c6e..f2e7ba1e10 100644
--- a/src/LocalStorage/LocalStorage.svelte
+++ b/src/LocalStorage/LocalStorage.svelte
@@ -1,9 +1,10 @@
 <script>
   /**
+   * @generics {T = any} T
    * @event {null} save
    * @event update - Fires when the stored value changes, either from a bound value update or when localStorage is modified from another tab/window.
-   * @property {any} prevValue
-   * @property {any} value
+   * @property {T} prevValue
+   * @property {T} value
    */
 
   /**
@@ -13,9 +14,9 @@
 
   /**
    * Provide a value to persist.
-   * @type {any}
+   * @type {T}
    */
-  export let value = "";
+  export let value = /** @type {T} */ ("");
 
   /**
    * Remove the persisted key value from the browser's local storage
diff --git a/src/Search/Search.svelte b/src/Search/Search.svelte
index fbe7f35d0e..84b315110c 100644
--- a/src/Search/Search.svelte
+++ b/src/Search/Search.svelte
@@ -1,5 +1,6 @@
 <script>
   /**
+   * @generics {T = any} T
    * @event {null} expand
    * @event {null} collapse
    * @restProps {input}
@@ -7,9 +8,9 @@
 
   /**
    * Specify the value of the search input.
-   * @type {any}
+   * @type {T}
    */
-  export let value = "";
+  export let value = /** @type {T} */ ("");
 
   /**
    * Specify the size of the search input.
diff --git a/src/SessionStorage/SessionStorage.svelte b/src/SessionStorage/SessionStorage.svelte
index 62874b60df..e4ce04ca7a 100644
--- a/src/SessionStorage/SessionStorage.svelte
+++ b/src/SessionStorage/SessionStorage.svelte
@@ -1,9 +1,10 @@
 <script>
   /**
+   * @generics {T = any} T
    * @event {null} save
    * @event update - Fires when the stored value changes, either from a bound value update or when sessionStorage is modified from another tab/window.
-   * @property {any} prevValue
-   * @property {any} value
+   * @property {T} prevValue
+   * @property {T} value
    */
 
   /**
@@ -13,9 +14,9 @@
 
   /**
    * Provide a value to persist.
-   * @type {any}
+   * @type {T}
    */
-  export let value = "";
+  export let value = /** @type {T} */ ("");
 
   /**
    * Remove the persisted key value from the browser's session storage
diff --git a/src/Theme/Theme.svelte b/src/Theme/Theme.svelte
index db8234684c..7c52834c7f 100644
--- a/src/Theme/Theme.svelte
+++ b/src/Theme/Theme.svelte
@@ -16,6 +16,7 @@
    */
 
   /**
+   * @generics {Tokens = Record<string, any>} Tokens
    * @typedef {"white" | "g10" | "g80" | "g90" | "g100"} CarbonTheme
    * @event update
    * @type {object}
@@ -32,9 +33,9 @@
   /**
    * Customize a theme with your own tokens.
    * @see https://carbondesignsystem.com/guidelines/themes/overview#customizing-a-theme
-   * @type {{ [token: string]: any; }}
+   * @type {Tokens}
    */
-  export let tokens = {};
+  export let tokens = /** @type {Tokens} */ ({});
 
   /** Set to `true` to persist the theme using window.localStorage */
   export let persist = false;
diff --git a/tests/Checkbox/Checkbox.test.ts b/tests/Checkbox/Checkbox.test.ts
index a02a6dfca4..3a29aedc1e 100644
--- a/tests/Checkbox/Checkbox.test.ts
+++ b/tests/Checkbox/Checkbox.test.ts
@@ -1,4 +1,6 @@
 import { render, screen } from "@testing-library/svelte";
+import type CheckboxComponent from "carbon-components-svelte/Checkbox/Checkbox.svelte";
+import type { ComponentProps } from "svelte";
 import { tick } from "svelte";
 import { user } from "../setup-tests";
 import CheckboxGroup from "./Checkbox.group.test.svelte";
@@ -503,4 +505,77 @@ describe("Checkbox", () => {
     const helperElement = screen.queryByText("Helper text message");
     expect(helperElement).not.toBeInTheDocument();
   });
+
+  describe("Generics", () => {
+    it("should support custom types with generics", () => {
+      type CustomValue = "option1" | "option2" | "option3";
+
+      type ComponentType = CheckboxComponent<CustomValue>;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<CustomValue | undefined>();
+      expectTypeOf<Props["group"]>().toEqualTypeOf<
+        ReadonlyArray<CustomValue> | undefined
+      >();
+    });
+
+    it("should default to any type when generic is not specified", () => {
+      type ComponentType = CheckboxComponent;
+      type Props = ComponentProps<ComponentType>;
+
+      // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+      expectTypeOf<Props["value"]>().toEqualTypeOf<any>();
+      expectTypeOf<Props["group"]>().toEqualTypeOf<
+        // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+        ReadonlyArray<any> | undefined
+      >();
+    });
+
+    it("should provide type-safe access when using group binding", () => {
+      type Status = "pending" | "approved" | "rejected";
+
+      const handleCheck = (checked: boolean) => {
+        expectTypeOf(checked).toEqualTypeOf<boolean>();
+      };
+
+      type ComponentType = CheckboxComponent<Status>;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<Status | undefined>();
+      expectTypeOf<Props["group"]>().toEqualTypeOf<
+        ReadonlyArray<Status> | undefined
+      >();
+      expectTypeOf(handleCheck).parameter(0).toEqualTypeOf<boolean>();
+    });
+
+    it("should work with object types", () => {
+      type Option = { id: string; label: string };
+
+      type ComponentType = CheckboxComponent<Option>;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<Option | undefined>();
+      expectTypeOf<Props["group"]>().toEqualTypeOf<
+        ReadonlyArray<Option> | undefined
+      >();
+    });
+
+    it("should work with 'as const' for type inference", () => {
+      const options = ["light", "dark", "auto"] as const;
+      type InferredType = (typeof options)[number];
+
+      expectTypeOf<typeof options>().toEqualTypeOf<
+        readonly ["light", "dark", "auto"]
+      >();
+      expectTypeOf<InferredType>().toEqualTypeOf<"light" | "dark" | "auto">();
+
+      type ComponentType = CheckboxComponent<InferredType>;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<InferredType | undefined>();
+      expectTypeOf<Props["group"]>().toEqualTypeOf<
+        ReadonlyArray<InferredType> | undefined
+      >();
+    });
+  });
 });
diff --git a/tests/DataTable/Toolbar.test.ts b/tests/DataTable/Toolbar.test.ts
index 68fdcba7ed..7cd8e1386b 100644
--- a/tests/DataTable/Toolbar.test.ts
+++ b/tests/DataTable/Toolbar.test.ts
@@ -1,4 +1,6 @@
 import { render, screen } from "@testing-library/svelte";
+import type ToolbarBatchActionsComponent from "carbon-components-svelte/DataTable/ToolbarBatchActions.svelte";
+import type { ComponentProps } from "svelte";
 import Toolbar from "./Toolbar.test.svelte";
 
 describe("DataTable Toolbar", () => {
@@ -191,5 +193,72 @@ describe("DataTable Toolbar", () => {
       cancelButton.click();
       expect(cancelFired).toBe(true);
     });
+
+    describe("Generics", () => {
+      it("should support custom Id types with generics", () => {
+        type CustomId = "row-1" | "row-2" | "row-3";
+
+        type ComponentType = ToolbarBatchActionsComponent<CustomId>;
+        type Props = ComponentProps<ComponentType>;
+
+        expectTypeOf<Props["selectedIds"]>().toEqualTypeOf<
+          ReadonlyArray<CustomId> | undefined
+        >();
+      });
+
+      it("should work with number Id types", () => {
+        type ComponentType = ToolbarBatchActionsComponent<number>;
+        type Props = ComponentProps<ComponentType>;
+
+        expectTypeOf<Props["selectedIds"]>().toEqualTypeOf<
+          ReadonlyArray<number> | undefined
+        >();
+      });
+
+      it("should provide type-safe selectedIds for handlers", () => {
+        type RowId = "a" | "b" | "c";
+
+        const handleSelected = (ids: ReadonlyArray<RowId>) => {
+          expectTypeOf(ids).toEqualTypeOf<ReadonlyArray<RowId>>();
+        };
+
+        type ComponentType = ToolbarBatchActionsComponent<RowId>;
+        type Props = ComponentProps<ComponentType>;
+
+        expectTypeOf<Props["selectedIds"]>().toEqualTypeOf<
+          ReadonlyArray<RowId> | undefined
+        >();
+        expectTypeOf<Parameters<typeof handleSelected>[0]>().toEqualTypeOf<
+          ReadonlyArray<RowId>
+        >();
+      });
+
+      it("should default to any type when generic is not specified", () => {
+        type ComponentType = ToolbarBatchActionsComponent;
+        type Props = ComponentProps<ComponentType>;
+
+        expectTypeOf<Props["selectedIds"]>().toEqualTypeOf<
+          // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+          ReadonlyArray<any> | undefined
+        >();
+      });
+
+      it("should work with 'as const' for type inference", () => {
+        const ids = ["id-a", "id-b", "id-c"] as const;
+        type InferredId = (typeof ids)[number];
+
+        expectTypeOf<typeof ids>().toEqualTypeOf<
+          readonly ["id-a", "id-b", "id-c"]
+        >();
+        expectTypeOf<InferredId>().toEqualTypeOf<"id-a" | "id-b" | "id-c">();
+
+        type ComponentType = ToolbarBatchActionsComponent<InferredId>;
+        type Props = ComponentProps<ComponentType>;
+
+        expectTypeOf<Props["selectedIds"]>().toEqualTypeOf<
+          ReadonlyArray<InferredId> | undefined
+        >();
+      });
+    });
   });
 });
diff --git a/tests/LocalStorage/LocalStorage.test.ts b/tests/LocalStorage/LocalStorage.test.ts
index d20aaaaec2..0e5beb6a9e 100644
--- a/tests/LocalStorage/LocalStorage.test.ts
+++ b/tests/LocalStorage/LocalStorage.test.ts
@@ -1,4 +1,6 @@
 import { render } from "@testing-library/svelte";
+import type LocalStorageComponent from "carbon-components-svelte/LocalStorage/LocalStorage.svelte";
+import type { ComponentEvents, ComponentProps } from "svelte";
 import { setupLocalStorageMock } from "../setup-tests";
 import LocalStorage from "./LocalStorage.test.svelte";
 
@@ -74,4 +76,111 @@ describe("LocalStorage", () => {
       expect.stringContaining("local-storage-key"),
     );
   });
+
+  describe("Generics", () => {
+    it("should support custom types with generics", () => {
+      type CustomValue = "option1" | "option2" | "option3";
+
+      type ComponentType = LocalStorageComponent<CustomValue>;
+      type Props = ComponentProps<ComponentType>;
+      type Events = ComponentEvents<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<CustomValue | undefined>();
+
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<{
+        prevValue: CustomValue;
+        value: CustomValue;
+      }>();
+    });
+
+    it("should default to any type when generic is not specified", () => {
+      type ComponentType = LocalStorageComponent;
+      type Props = ComponentProps<ComponentType>;
+      type Events = ComponentEvents<ComponentType>;
+
+      // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+      expectTypeOf<Props["value"]>().toEqualTypeOf<any>();
+
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<{
+        // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+        prevValue: any;
+        // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+        value: any;
+      }>();
+    });
+
+    it("should provide type-safe access to custom types in event handlers", () => {
+      type Status = "pending" | "approved" | "rejected";
+
+      const handleUpdate = (detail: { prevValue: Status; value: Status }) => {
+        expectTypeOf(detail.value).toEqualTypeOf<Status>();
+        if (detail.value === "pending") {
+          expectTypeOf(detail.value).toEqualTypeOf<"pending">();
+        }
+      };
+
+      expectTypeOf(handleUpdate).parameter(0).toEqualTypeOf<{
+        prevValue: Status;
+        value: Status;
+      }>();
+
+      type ComponentType = LocalStorageComponent<Status>;
+      type Events = ComponentEvents<ComponentType>;
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<
+        Parameters<typeof handleUpdate>[0]
+      >();
+    });
+
+    it("should work with object types", () => {
+      type ThemeSettings = { theme: "light" | "dark"; fontSize: number };
+
+      type ComponentType = LocalStorageComponent<ThemeSettings>;
+      type Props = ComponentProps<ComponentType>;
+      type Events = ComponentEvents<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<ThemeSettings | undefined>();
+
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<{
+        prevValue: ThemeSettings;
+        value: ThemeSettings;
+      }>();
+    });
+
+    it("should work with 'as const' for type inference", () => {
+      const themeOptions = ["light", "dark", "auto"] as const;
+      type InferredType = (typeof themeOptions)[number];
+
+      expectTypeOf<typeof themeOptions>().toEqualTypeOf<
+        readonly ["light", "dark", "auto"]
+      >();
+      expectTypeOf<InferredType>().toEqualTypeOf<"light" | "dark" | "auto">();
+
+      type ComponentType = LocalStorageComponent<InferredType>;
+      type Props = ComponentProps<ComponentType>;
+      type Events = ComponentEvents<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<InferredType | undefined>();
+
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<{
+        prevValue: InferredType;
+        value: InferredType;
+      }>();
+    });
+  });
 });
diff --git a/tests/Search/Search.test.ts b/tests/Search/Search.test.ts
index 12db01a974..6058672247 100644
--- a/tests/Search/Search.test.ts
+++ b/tests/Search/Search.test.ts
@@ -1,4 +1,6 @@
 import { render, screen } from "@testing-library/svelte";
+import type SearchComponent from "carbon-components-svelte/Search/Search.svelte";
+import type { ComponentProps } from "svelte";
 import { user } from "../setup-tests";
 import SearchSlot from "./Search.slot.test.svelte";
 import Search from "./Search.test.svelte";
@@ -106,4 +108,49 @@ describe("Search", () => {
     const customLabel = screen.getByText("Custom label content");
     expect(customLabel).toBeInTheDocument();
   });
+
+  describe("Generics", () => {
+    it("should support custom types with generics", () => {
+      type CustomValue = "option1" | "option2" | "option3";
+
+      type ComponentType = SearchComponent<CustomValue>;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<CustomValue | undefined>();
+    });
+
+    it("should default to any type when generic is not specified", () => {
+      type ComponentType = SearchComponent;
+      type Props = ComponentProps<ComponentType>;
+
+      // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+      expectTypeOf<Props["value"]>().toEqualTypeOf<any>();
+    });
+
+    it("should work with object types", () => {
+      type SearchFilters = { query: string; category: string };
+
+      type ComponentType = SearchComponent<SearchFilters>;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<SearchFilters | undefined>();
+    });
+
+    it("should work with 'as const' for type inference", () => {
+      const suggestions = ["apple", "banana", "cherry"] as const;
+      type InferredType = (typeof suggestions)[number];
+
+      expectTypeOf<typeof suggestions>().toEqualTypeOf<
+        readonly ["apple", "banana", "cherry"]
+      >();
+      expectTypeOf<InferredType>().toEqualTypeOf<
+        "apple" | "banana" | "cherry"
+      >();
+
+      type ComponentType = SearchComponent<InferredType>;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<InferredType | undefined>();
+    });
+  });
 });
diff --git a/tests/SessionStorage/SessionStorage.test.ts b/tests/SessionStorage/SessionStorage.test.ts
index ce48adea1a..b6ecb5755a 100644
--- a/tests/SessionStorage/SessionStorage.test.ts
+++ b/tests/SessionStorage/SessionStorage.test.ts
@@ -1,4 +1,6 @@
 import { render } from "@testing-library/svelte";
+import type SessionStorageComponent from "carbon-components-svelte/SessionStorage/SessionStorage.svelte";
+import type { ComponentEvents, ComponentProps } from "svelte";
 import { setupSessionStorageMock } from "../setup-tests";
 import SessionStorage from "./SessionStorage.test.svelte";
 
@@ -74,4 +76,111 @@ describe("SessionStorage", () => {
       expect.stringContaining("session-storage-key"),
     );
   });
+
+  describe("Generics", () => {
+    it("should support custom types with generics", () => {
+      type CustomValue = "option1" | "option2" | "option3";
+
+      type ComponentType = SessionStorageComponent<CustomValue>;
+      type Props = ComponentProps<ComponentType>;
+      type Events = ComponentEvents<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<CustomValue | undefined>();
+
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<{
+        prevValue: CustomValue;
+        value: CustomValue;
+      }>();
+    });
+
+    it("should default to any type when generic is not specified", () => {
+      type ComponentType = SessionStorageComponent;
+      type Props = ComponentProps<ComponentType>;
+      type Events = ComponentEvents<ComponentType>;
+
+      // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+      expectTypeOf<Props["value"]>().toEqualTypeOf<any>();
+
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<{
+        // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+        prevValue: any;
+        // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+        value: any;
+      }>();
+    });
+
+    it("should provide type-safe access to custom types in event handlers", () => {
+      type Status = "pending" | "approved" | "rejected";
+
+      const handleUpdate = (detail: { prevValue: Status; value: Status }) => {
+        expectTypeOf(detail.value).toEqualTypeOf<Status>();
+        if (detail.value === "pending") {
+          expectTypeOf(detail.value).toEqualTypeOf<"pending">();
+        }
+      };
+
+      expectTypeOf(handleUpdate).parameter(0).toEqualTypeOf<{
+        prevValue: Status;
+        value: Status;
+      }>();
+
+      type ComponentType = SessionStorageComponent<Status>;
+      type Events = ComponentEvents<ComponentType>;
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<
+        Parameters<typeof handleUpdate>[0]
+      >();
+    });
+
+    it("should work with object types", () => {
+      type ThemeSettings = { theme: "light" | "dark"; fontSize: number };
+
+      type ComponentType = SessionStorageComponent<ThemeSettings>;
+      type Props = ComponentProps<ComponentType>;
+      type Events = ComponentEvents<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<ThemeSettings | undefined>();
+
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<{
+        prevValue: ThemeSettings;
+        value: ThemeSettings;
+      }>();
+    });
+
+    it("should work with 'as const' for type inference", () => {
+      const themeOptions = ["light", "dark", "auto"] as const;
+      type InferredType = (typeof themeOptions)[number];
+
+      expectTypeOf<typeof themeOptions>().toEqualTypeOf<
+        readonly ["light", "dark", "auto"]
+      >();
+      expectTypeOf<InferredType>().toEqualTypeOf<"light" | "dark" | "auto">();
+
+      type ComponentType = SessionStorageComponent<InferredType>;
+      type Props = ComponentProps<ComponentType>;
+      type Events = ComponentEvents<ComponentType>;
+
+      expectTypeOf<Props["value"]>().toEqualTypeOf<InferredType | undefined>();
+
+      type UpdateEvent = Events["update"];
+      type UpdateEventDetail =
+        UpdateEvent extends CustomEvent<infer T> ? T : never;
+      expectTypeOf<UpdateEventDetail>().toEqualTypeOf<{
+        prevValue: InferredType;
+        value: InferredType;
+      }>();
+    });
+  });
 });
diff --git a/tests/Theme/Theme.test.ts b/tests/Theme/Theme.test.ts
index a0e1a769c3..ef7e73dffb 100644
--- a/tests/Theme/Theme.test.ts
+++ b/tests/Theme/Theme.test.ts
@@ -1,6 +1,8 @@
 import { render, screen } from "@testing-library/svelte";
+import type ThemeComponent from "carbon-components-svelte/Theme/Theme.svelte";
 import type { CarbonTheme } from "carbon-components-svelte/Theme/Theme.svelte";
 import { themes } from "carbon-components-svelte/Theme/Theme.svelte";
+import type { ComponentProps } from "svelte";
 import { tick } from "svelte";
 import { user } from "../setup-tests";
 import Theme from "./Theme.test.svelte";
@@ -242,4 +244,37 @@ describe("Theme", () => {
     await user.selectOptions(select, "g10");
     expect(select).toHaveTextContent(themes.g10);
   });
+
+  describe("Generics", () => {
+    it("should support custom token types with generics", () => {
+      type CustomTokens = {
+        "interactive-01": string;
+        "ui-background": string;
+      };
+
+      type ComponentType = ThemeComponent<CustomTokens>;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["tokens"]>().toEqualTypeOf<CustomTokens | undefined>();
+    });
+
+    it("should default to Record<string, any> when generic is not specified", () => {
+      type ComponentType = ThemeComponent;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["tokens"]>().toEqualTypeOf<
+        // biome-ignore lint/suspicious/noExplicitAny: Testing default any type
+        Record<string, any> | undefined
+      >();
+    });
+
+    it("should work with index signature token types", () => {
+      type TokenMap = Record<string, string | number>;
+
+      type ComponentType = ThemeComponent<TokenMap>;
+      type Props = ComponentProps<ComponentType>;
+
+      expectTypeOf<Props["tokens"]>().toEqualTypeOf<TokenMap | undefined>();
+    });
+  });
 });