chrome-web-ai-types 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kevin Uehara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,234 @@
+# chrome-web-ai-types
+
+TypeScript definitions for **Chrome’s built-in AI APIs** (Summarizer, Writer, Rewriter, Proofreader, Translator, Language Detector, and Prompt API). Works with TypeScript, React, Angular, Vue, and any project using TypeScript.
+
+## Installation
+
+```bash
+npm install chrome-web-ai-types
+# or
+yarn add chrome-web-ai-types
+# or
+pnpm add chrome-web-ai-types
+```
+
+## Requirements
+
+- **TypeScript** 4.5+ (5.x recommended)
+- **Chrome** 138+ (APIs are evolving; see [Chrome docs](https://developer.chrome.com/docs/ai))
+- Some APIs may require an [origin trial](https://developer.chrome.com/docs/origintrials/) or Chrome flags
+
+## APIs covered
+
+| API | Description |
+|-----|-------------|
+| **Summarizer** | Summarize text (key-points, tldr, teaser, headline) |
+| **Writer** | Generate text (tone, format, length) |
+| **Rewriter** | Rewrite text (tone, format, length) |
+| **Proofreader** | Grammar and spelling review |
+| **Translator** | Translate between languages |
+| **LanguageDetector** | Detect text language |
+| **LanguageModel** (Prompt API) | Prompts and sessions with Gemini Nano |
+| **window.ai** | `createLanguageModel()` (legacy) |
+
+All expose `availability()`, `create(options?)`, streaming where applicable, and language options when documented.
+
+---
+
+## Usage by project type
+
+### TypeScript (Node / generic bundler)
+
+The declarations are **global**. After installing the package, types are picked up automatically.
+
+```ts
+// No import needed
+async function main() {
+  if (typeof Summarizer === "undefined") {
+    console.log("Summarizer not available in this environment.");
+    return;
+  }
+
+  const availability = await Summarizer.availability();
+  if (availability === "unavailable") return;
+
+  const summarizer = await Summarizer.create({
+    type: "key-points",
+    format: "markdown",
+    length: "short",
+  });
+
+  const summary = await summarizer.summarize("Your long text here...");
+  console.log(summary);
+}
+```
+
+Ensure your `tsconfig.json` includes the right lib (usually automatic after install):
+
+```json
+{
+  "compilerOptions": {
+    "lib": ["ES2020", "DOM"]
+  }
+}
+```
+
+---
+
+### React (TypeScript)
+
+Install the package and use the APIs in components or hooks. Global types are available without imports.
+
+```tsx
+// src/hooks/useSummarizer.ts
+import { useState, useCallback } from "react";
+
+export function useSummarizer() {
+  const [summary, setSummary] = useState<string>("");
+  const [loading, setLoading] = useState(false);
+
+  const summarize = useCallback(async (text: string) => {
+    if (typeof Summarizer === "undefined") {
+      throw new Error("Summarizer API not available.");
+    }
+    setLoading(true);
+    try {
+      const availability = await Summarizer.availability();
+      if (availability === "unavailable") {
+        throw new Error("Model unavailable.");
+      }
+      const summarizer = await Summarizer.create({ type: "key-points" });
+      const result = await summarizer.summarize(text);
+      setSummary(result);
+      return result;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  return { summary, loading, summarize };
+}
+```
+
+```tsx
+// src/components/SummarizerDemo.tsx
+import { useSummarizer } from "../hooks/useSummarizer";
+
+export function SummarizerDemo() {
+  const { summary, loading, summarize } = useSummarizer();
+
+  return (
+    <div>
+      <button
+        disabled={loading}
+        onClick={() => summarize("Long text to summarize...")}
+      >
+        {loading ? "Summarizing..." : "Summarize"}
+      </button>
+      {summary && <p>{summary}</p>}
+    </div>
+  );
+}
+```
+
+In React + Vite or Create React App, a `tsconfig` with `"lib": ["ES2020", "DOM"]` is enough.
+
+--
+
+Install and use in `<script setup lang="ts">` or composables; global types are recognized.
+
+```vue
+<!-- src/components/LanguageDetector.vue -->
+<script setup lang="ts">
+import { ref } from "vue";
+
+const text = ref("");
+const detectedLanguage = ref<string | null>(null);
+const loading = ref(false);
+
+async function detect() {
+  if (typeof LanguageDetector === "undefined") return;
+  loading.value = true;
+  try {
+    const detector = await LanguageDetector.create();
+    const results = await detector.detect(text.value);
+    detectedLanguage.value = results[0]?.detectedLanguage ?? null;
+  } finally {
+    loading.value = false;
+  }
+}
+</script>
+
+<template>
+  <div>
+    <textarea v-model="text" placeholder="Enter some text" />
+    <button :disabled="loading" @click="detect">Detect language</button>
+    <p v-if="detectedLanguage">Language: {{ detectedLanguage }}</p>
+  </div>
+</template>
+```
+
+---
+
+### Checking availability
+
+APIs may be missing (older browser) or not ready (model not downloaded). Always check at runtime:
+
+```ts
+if (typeof Summarizer === "undefined") {
+  // API does not exist in this environment
+  return;
+}
+
+const availability = await Summarizer.availability();
+// "available" | "unavailable" | "downloadable"
+
+if (availability === "unavailable") {
+  // Cannot use
+  return;
+}
+
+if (availability === "downloadable") {
+  // Can call create(); model will download (may take a while)
+  const summarizer = await Summarizer.create({
+    monitor(m) {
+      m.addEventListener("downloadprogress", (e) => {
+        console.log(`Download: ${e.loaded * 100}%`);
+      });
+    },
+  });
+  // ...
+}
+```
+
+---
+
+## Type tests (this repo)
+
+```bash
+npm install
+npm run typecheck
+# or
+npm test
+```
+
+Files under `tests/` assert that the definitions accept valid usage and reject invalid usage.
+
+---
+
+## Official documentation
+
+- [Chrome AI APIs overview](https://developer.chrome.com/docs/ai)
+- [Summarizer](https://developer.chrome.com/docs/ai/summarizer-api)
+- [Writer](https://developer.chrome.com/docs/ai/writer-api)
+- [Rewriter](https://developer.chrome.com/docs/ai/rewriter-api)
+- [Proofreader](https://developer.chrome.com/docs/ai/proofreader-api)
+- [Translator](https://developer.chrome.com/docs/ai/translator-api)
+- [Language Detector](https://developer.chrome.com/docs/ai/language-detection)
+- [Prompt API](https://developer.chrome.com/docs/ai/prompt-api)
+
+---
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,432 @@
+/// <reference lib="es2018.asynciterable" />
+export {};
+
+declare global {
+  /* ---------------------------
+     SUMMARIZER
+     https://developer.chrome.com/docs/ai/summarizer-api
+  --------------------------- */
+
+  type SummarizerType = "key-points" | "tldr" | "teaser" | "headline";
+  type SummarizerFormat = "markdown" | "plain-text";
+  type SummarizerLength = "short" | "medium" | "long";
+  type SummarizerPreference = "auto" | "speed" | "capability";
+  type SummarizerAvailability = "available" | "unavailable" | "downloadable";
+
+  interface SummarizerDownloadProgressEvent {
+    readonly loaded: number;
+  }
+
+  interface SummarizerMonitor {
+    addEventListener(
+      type: "downloadprogress",
+      listener: (e: SummarizerDownloadProgressEvent) => void,
+    ): void;
+  }
+
+  interface SummarizerOptions {
+    sharedContext?: string;
+    type?: SummarizerType;
+    format?: SummarizerFormat;
+    length?: SummarizerLength;
+    preference?: SummarizerPreference;
+    expectedInputLanguages?: string[];
+    outputLanguage?: string;
+    expectedContextLanguages?: string[];
+    monitor?(m: SummarizerMonitor): void;
+  }
+
+  interface SummarizerSummarizeOptions {
+    /** Optional context to improve the summary for this call. */
+    context?: string;
+  }
+
+  interface Summarizer {
+    /** Batch summarization: process full input and return the summary. */
+    summarize(
+      text: string,
+      options?: SummarizerSummarizeOptions,
+    ): Promise<string>;
+    /** Streaming summarization: yields chunks as the summary is generated. */
+    summarizeStreaming(
+      text: string,
+      options?: SummarizerSummarizeOptions,
+    ): AsyncGenerator<string, void, undefined>;
+  }
+
+  interface SummarizerConstructor {
+    create(options?: SummarizerOptions): Promise<Summarizer>;
+    availability(): Promise<SummarizerAvailability>;
+  }
+
+  var Summarizer: SummarizerConstructor;
+
+  /* ---------------------------
+     WRITER
+     https://developer.chrome.com/docs/ai/writer-api
+  --------------------------- */
+
+  type WriterTone = "formal" | "neutral" | "casual";
+  type WriterFormat = "markdown" | "plain-text";
+  type WriterLength = "short" | "medium" | "long";
+  type WriterAvailability = "available" | "unavailable" | "downloadable";
+
+  interface WriterDownloadProgressEvent {
+    readonly loaded: number;
+  }
+
+  interface WriterMonitor {
+    addEventListener(
+      type: "downloadprogress",
+      listener: (e: WriterDownloadProgressEvent) => void,
+    ): void;
+  }
+
+  interface WriterOptions {
+    tone?: WriterTone;
+    format?: WriterFormat;
+    length?: WriterLength;
+    sharedContext?: string;
+    expectedInputLanguages?: string[];
+    expectedContextLanguages?: string[];
+    outputLanguage?: string;
+    monitor?(m: WriterMonitor): void;
+    signal?: AbortSignal;
+  }
+
+  interface WriterWriteOptions {
+    context?: string;
+    signal?: AbortSignal;
+  }
+
+  interface Writer {
+    write(prompt: string, options?: WriterWriteOptions): Promise<string>;
+    writeStreaming(
+      prompt: string,
+      options?: WriterWriteOptions,
+    ): AsyncGenerator<string, void, undefined>;
+    destroy(): void;
+  }
+
+  interface WriterConstructor {
+    create(options?: WriterOptions): Promise<Writer>;
+    availability(): Promise<WriterAvailability>;
+  }
+
+  var Writer: WriterConstructor;
+
+  /* ---------------------------
+     REWRITER
+     https://developer.chrome.com/docs/ai/rewriter-api
+  --------------------------- */
+
+  type RewriterTone = "more-formal" | "as-is" | "more-casual";
+  type RewriterFormat = "as-is" | "markdown" | "plain-text";
+  type RewriterLength = "shorter" | "as-is" | "longer";
+  type RewriterAvailability = "available" | "unavailable" | "downloadable";
+
+  interface RewriterDownloadProgressEvent {
+    readonly loaded: number;
+  }
+
+  interface RewriterMonitor {
+    addEventListener(
+      type: "downloadprogress",
+      listener: (e: RewriterDownloadProgressEvent) => void,
+    ): void;
+  }
+
+  interface RewriterOptions {
+    tone?: RewriterTone;
+    format?: RewriterFormat;
+    length?: RewriterLength;
+    sharedContext?: string;
+    expectedInputLanguages?: string[];
+    expectedContextLanguages?: string[];
+    outputLanguage?: string;
+    monitor?(m: RewriterMonitor): void;
+    signal?: AbortSignal;
+  }
+
+  interface RewriterRewriteOptions {
+    context?: string;
+    tone?: RewriterTone;
+    signal?: AbortSignal;
+  }
+
+  interface Rewriter {
+    rewrite(text: string, options?: RewriterRewriteOptions): Promise<string>;
+    rewriteStreaming(
+      text: string,
+      options?: RewriterRewriteOptions,
+    ): AsyncGenerator<string, void, undefined>;
+    destroy(): void;
+  }
+
+  interface RewriterConstructor {
+    create(options?: RewriterOptions): Promise<Rewriter>;
+    availability(): Promise<RewriterAvailability>;
+  }
+
+  var Rewriter: RewriterConstructor;
+
+  /* ---------------------------
+     PROOFREADER
+     https://developer.chrome.com/docs/ai/proofreader-api
+  --------------------------- */
+
+  type ProofreaderAvailability = "available" | "unavailable" | "downloadable";
+
+  interface ProofreaderDownloadProgressEvent {
+    readonly loaded: number;
+  }
+
+  interface ProofreaderMonitor {
+    addEventListener(
+      type: "downloadprogress",
+      listener: (e: ProofreaderDownloadProgressEvent) => void,
+    ): void;
+  }
+
+  interface ProofreaderOptions {
+    expectedInputLanguages?: string[];
+    monitor?(m: ProofreaderMonitor): void;
+  }
+
+  interface ProofreaderCorrection {
+    startIndex: number;
+    endIndex: number;
+    replacement?: string;
+  }
+
+  interface ProofreadResult {
+    correctedInput: string;
+    corrections: ProofreaderCorrection[];
+  }
+
+  interface Proofreader {
+    proofread(text: string): Promise<ProofreadResult>;
+  }
+
+  interface ProofreaderConstructor {
+    create(options?: ProofreaderOptions): Promise<Proofreader>;
+    availability(): Promise<ProofreaderAvailability>;
+  }
+
+  var Proofreader: ProofreaderConstructor;
+
+  /* ---------------------------
+     TRANSLATOR
+     https://developer.chrome.com/docs/ai/translator-api
+  --------------------------- */
+
+  type TranslatorAvailability = "available" | "unavailable" | "downloadable";
+
+  interface TranslatorDownloadProgressEvent {
+    readonly loaded: number;
+  }
+
+  interface TranslatorMonitor {
+    addEventListener(
+      type: "downloadprogress",
+      listener: (e: TranslatorDownloadProgressEvent) => void,
+    ): void;
+  }
+
+  interface TranslatorOptions {
+    sourceLanguage: string;
+    targetLanguage: string;
+    monitor?(m: TranslatorMonitor): void;
+  }
+
+  interface TranslatorAvailabilityOptions {
+    sourceLanguage: string;
+    targetLanguage: string;
+  }
+
+  interface Translator {
+    translate(text: string): Promise<string>;
+    translateStreaming(text: string): AsyncGenerator<string, void, undefined>;
+  }
+
+  interface TranslatorConstructor {
+    create(options: TranslatorOptions): Promise<Translator>;
+    availability(
+      options?: TranslatorAvailabilityOptions,
+    ): Promise<TranslatorAvailability>;
+  }
+
+  var Translator: TranslatorConstructor;
+
+  /* ---------------------------
+     LANGUAGE DETECTOR
+     https://developer.chrome.com/docs/ai/language-detection
+  --------------------------- */
+
+  type LanguageDetectorAvailability =
+    | "available"
+    | "unavailable"
+    | "downloadable";
+
+  interface LanguageDetectorDownloadProgressEvent {
+    readonly loaded: number;
+  }
+
+  interface LanguageDetectorMonitor {
+    addEventListener(
+      type: "downloadprogress",
+      listener: (e: LanguageDetectorDownloadProgressEvent) => void,
+    ): void;
+  }
+
+  interface LanguageDetectionResult {
+    detectedLanguage: string;
+    confidence: number;
+  }
+
+  interface LanguageDetectorOptions {
+    monitor?(m: LanguageDetectorMonitor): void;
+  }
+
+  interface LanguageDetector {
+    detect(text: string): Promise<LanguageDetectionResult[]>;
+  }
+
+  interface LanguageDetectorConstructor {
+    create(options?: LanguageDetectorOptions): Promise<LanguageDetector>;
+    availability(): Promise<LanguageDetectorAvailability>;
+  }
+
+  var LanguageDetector: LanguageDetectorConstructor;
+
+  /* ---------------------------
+     PROMPT API (Language Model)
+     https://developer.chrome.com/docs/ai/prompt-api
+  --------------------------- */
+
+  type LanguageModelAvailability = "available" | "unavailable" | "downloading";
+
+  interface LanguageModelDownloadProgressEvent {
+    readonly loaded: number;
+  }
+
+  interface LanguageModelMonitor {
+    addEventListener(
+      type: "downloadprogress",
+      listener: (e: LanguageModelDownloadProgressEvent) => void,
+    ): void;
+  }
+
+  interface LanguageModelExpectedInput {
+    type: "text" | "image" | "audio";
+    languages?: string[];
+  }
+
+  /** Expected output: text only, with optional languages. */
+  interface LanguageModelExpectedOutput {
+    type: "text";
+    languages?: string[];
+  }
+
+  interface TextContentPart {
+    type: "text";
+    value: string;
+  }
+
+  interface ImageContentPart {
+    type: "image";
+    value:
+      | HTMLImageElement
+      | SVGImageElement
+      | HTMLVideoElement
+      | HTMLCanvasElement
+      | ImageBitmap
+      | OffscreenCanvas
+      | VideoFrame
+      | Blob
+      | ImageData;
+  }
+
+  interface AudioContentPart {
+    type: "audio";
+    value: AudioBuffer | ArrayBufferView | ArrayBuffer | Blob;
+  }
+
+  type LanguageModelContentPart =
+    | TextContentPart
+    | ImageContentPart
+    | AudioContentPart;
+
+  interface LanguageModelPromptMessage {
+    role: "system" | "user" | "assistant";
+    content: string | LanguageModelContentPart[];
+    prefix?: boolean;
+  }
+
+  interface LanguageModelParams {
+    defaultTopK: number;
+    maxTopK: number;
+    defaultTemperature: number;
+    maxTemperature: number;
+  }
+
+  interface LanguageModelCreateOptions {
+    monitor?(m: LanguageModelMonitor): void;
+    signal?: AbortSignal;
+    initialPrompts?: LanguageModelPromptMessage[];
+    expectedInputs?: LanguageModelExpectedInput[];
+    expectedOutputs?: LanguageModelExpectedOutput[];
+    temperature?: number;
+    topK?: number;
+  }
+
+  interface LanguageModelAvailabilityOptions {
+    expectedInputs?: LanguageModelExpectedInput[];
+    expectedOutputs?: LanguageModelExpectedOutput[];
+  }
+
+  interface LanguageModelPromptOptions {
+    responseConstraint?: object;
+    omitResponseConstraintInput?: boolean;
+    signal?: AbortSignal;
+  }
+
+  interface LanguageModelSession {
+    prompt(
+      prompt: string | LanguageModelPromptMessage[],
+      options?: LanguageModelPromptOptions,
+    ): Promise<string>;
+    promptStreaming(
+      prompt: string | LanguageModelPromptMessage[],
+      options?: LanguageModelPromptOptions,
+    ): AsyncGenerator<string, void, undefined>;
+    append(messages: LanguageModelPromptMessage[]): Promise<void>;
+    clone(options?: { signal?: AbortSignal }): Promise<LanguageModelSession>;
+    destroy(): void;
+    readonly contextUsage: number;
+    readonly contextWindow: number;
+    measureContextUsage?(
+      prompt?: string | LanguageModelPromptMessage[],
+      options?: Pick<LanguageModelPromptOptions, "responseConstraint">,
+    ): Promise<{ used: number; total: number }>;
+  }
+
+  interface LanguageModelConstructor {
+    availability(
+      options?: LanguageModelAvailabilityOptions,
+    ): Promise<LanguageModelAvailability>;
+    create(options?: LanguageModelCreateOptions): Promise<LanguageModelSession>;
+    params?(): Promise<LanguageModelParams>;
+  }
+
+  var LanguageModel: LanguageModelConstructor;
+
+  /** @deprecated Prefer global LanguageModel. createLanguageModel() may be removed in the future. */
+  interface AI {
+    createLanguageModel(): Promise<LanguageModelSession>;
+  }
+
+  interface Window {
+    ai: AI;
+  }
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "chrome-web-ai-types",
+  "version": "0.1.0",
+  "description": "TypeScript definitions for Chrome Web AI APIs",
+  "types": "index.d.ts",
+  "keywords": [
+    "typescript",
+    "types",
+    "web-ai",
+    "chrome-ai",
+    "built-in-ai"
+  ],
+  "author": "Kevin Uehara",
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "test": "npm run typecheck"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/tests/invalid-usage.ts

@@ -0,0 +1,37 @@
+/// <reference path="../index.d.ts" />
+/**
+ * Type tests: these lines must FAIL type-checking.
+ * Each block uses @ts-expect-error to assert that the wrong usage is rejected.
+ * Run: npm run typecheck — this file should still compile because errors are expected.
+ */
+
+async function invalidSummarizer() {
+  if (typeof Summarizer === "undefined") return;
+  // @ts-expect-error - create() expects options object or undefined, not string
+  await Summarizer.create("invalid");
+  const s = await Summarizer.create();
+  // @ts-expect-error - summarize() first arg must be string
+  await s.summarize(123);
+}
+
+async function invalidTranslator() {
+  if (typeof Translator === "undefined") return;
+  // @ts-expect-error - create() requires sourceLanguage and targetLanguage
+  await Translator.create({});
+  // @ts-expect-error - sourceLanguage is required
+  await Translator.create({ targetLanguage: "en" });
+}
+
+async function invalidProofreader() {
+  if (typeof Proofreader === "undefined") return;
+  const p = await Proofreader.create();
+  // @ts-expect-error - proofread() returns Promise<ProofreadResult>, not string
+  const x: string = await p.proofread("text");
+}
+
+async function invalidLanguageDetector() {
+  if (typeof LanguageDetector === "undefined") return;
+  const d = await LanguageDetector.create();
+  // @ts-expect-error - detect() returns Promise<LanguageDetectionResult[]>, not string
+  const r: string = await d.detect("hi");
+}

package/tests/valid-usage.ts

@@ -0,0 +1,125 @@
+/// <reference path="../index.d.ts" />
+/**
+ * Type tests: valid usage of Chrome Web AI APIs.
+ * Run: npm run typecheck
+ * If this file compiles, the type definitions are working.
+ */
+
+async function testSummarizer() {
+  if (typeof Summarizer === "undefined") return;
+  const availability: SummarizerAvailability = await Summarizer.availability();
+  if (availability === "unavailable") return;
+  const summarizer = await Summarizer.create({
+    type: "key-points",
+    format: "markdown",
+    length: "short",
+  });
+  const summary: string = await summarizer.summarize("Some long text.");
+  const stream = summarizer.summarizeStreaming("More text.", { context: "Article" });
+  for await (const chunk of stream) {
+    const _: string = chunk;
+  }
+}
+
+async function testWriter() {
+  if (typeof Writer === "undefined") return;
+  const writer = await Writer.create({ tone: "formal", format: "plain-text" });
+  const result: string = await writer.write("Write an email.", { context: "Work" });
+  const stream = writer.writeStreaming("Another prompt.");
+  for await (const chunk of stream) {
+    const _: string = chunk;
+  }
+  writer.destroy();
+}
+
+async function testRewriter() {
+  if (typeof Rewriter === "undefined") return;
+  const rewriter = await Rewriter.create({
+    tone: "more-formal",
+    length: "as-is",
+  });
+  const result: string = await rewriter.rewrite("fix this text", {
+    context: "Email",
+    tone: "more-casual",
+  });
+  const stream = rewriter.rewriteStreaming("text", { context: "Review" });
+  for await (const chunk of stream) {
+    const _: string = chunk;
+  }
+  rewriter.destroy();
+}
+
+async function testProofreader() {
+  if (typeof Proofreader === "undefined") return;
+  const proofreader = await Proofreader.create({
+    expectedInputLanguages: ["en"],
+  });
+  const result: ProofreadResult = await proofreader.proofread(
+    "I seen him yesterday."
+  );
+  const _corrected: string = result.correctedInput;
+  const _corrections: ProofreaderCorrection[] = result.corrections;
+  result.corrections.forEach((c) => {
+    const _s: number = c.startIndex;
+    const _e: number = c.endIndex;
+  });
+}
+
+async function testTranslator() {
+  if (typeof Translator === "undefined") return;
+  const availability = await Translator.availability({
+    sourceLanguage: "en",
+    targetLanguage: "es",
+  });
+  const translator = await Translator.create({
+    sourceLanguage: "en",
+    targetLanguage: "es",
+  });
+  const translated: string = await translator.translate("Hello world");
+  const stream = translator.translateStreaming("Long text...");
+  for await (const chunk of stream) {
+    const _: string = chunk;
+  }
+}
+
+async function testLanguageDetector() {
+  if (typeof LanguageDetector === "undefined") return;
+  const detector = await LanguageDetector.create();
+  const results: LanguageDetectionResult[] = await detector.detect("Hallo Welt");
+  results.forEach((r) => {
+    const _lang: string = r.detectedLanguage;
+    const _conf: number = r.confidence;
+  });
+}
+
+async function testLanguageModel() {
+  if (typeof LanguageModel === "undefined") return;
+  const availability = await LanguageModel.availability({
+    expectedInputs: [{ type: "text", languages: ["en"] }],
+    expectedOutputs: [{ type: "text", languages: ["en"] }],
+  });
+  if (availability === "unavailable") return;
+  const session = await LanguageModel.create({
+    expectedInputs: [{ type: "text", languages: ["en"] }],
+    expectedOutputs: [{ type: "text", languages: ["en"] }],
+  });
+  const response: string = await session.prompt("Say hello");
+  const stream = session.promptStreaming("Write a poem");
+  for await (const chunk of stream) {
+    const _: string = chunk;
+  }
+  await session.append([
+    { role: "user", content: "Follow-up" },
+  ]);
+  const cloned = await session.clone();
+  const _usage: number = session.contextUsage;
+  const _window: number = session.contextWindow;
+  session.destroy();
+}
+
+async function testWindowAi() {
+  if (typeof window === "undefined" || !window.ai) return;
+  const session = await window.ai.createLanguageModel();
+  const _: string = await session.prompt("Hi");
+  session.destroy();
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "strict": true,
+    "lib": ["ES2020", "DOM"]
+  },
+  "include": ["index.d.ts"]
+}

package/tsconfig.test.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["index.d.ts", "tests/**/*.ts"]
+}