ty-fetch 0.0.2-beta.7 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alister Norris
+
+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

@@ -1,37 +1,91 @@
-# ty-fetch
+<p align="center">
+  <img src="logo.png" alt="ty-fetch" width="350" />
+</p>
 
-TypeScript tooling that validates API calls against OpenAPI specs. Get autocomplete, diagnostics, and fully typed responses with zero manual types.
+<h1 align="center">ty-fetch</h1>
 
-```ts
-import tf from "ty-fetch";
+[![npm version](https://img.shields.io/npm/v/ty-fetch.svg)](https://www.npmjs.com/package/ty-fetch)
+[![license](https://img.shields.io/npm/l/ty-fetch.svg)](https://github.com/alnorris/ty-fetch/blob/main/LICENSE)
+[![CI](https://github.com/alnorris/ty-fetch/actions/workflows/ci.yml/badge.svg)](https://github.com/alnorris/ty-fetch/actions/workflows/ci.yml)
 
-const customers = await tf.get("https://api.stripe.com/v1/customers").json();
-// customers is fully typed — data, has_more, object, url all autocomplete
+**A tiny, zero-dependency HTTP client that auto-discovers your OpenAPI specs and types your API calls on-the-fly. No codegen, no build step — types generated by a TS plugin.**
 
-tf.get("https://api.stripe.com/v1/cutsomers");
-//                                  ~~~~~~~~~~
-// Error: Path '/v1/cutsomers' does not exist in Stripe API.
-//        Did you mean '/v1/customers'?
+```bash
+npm install ty-fetch
 ```
 
-## What it does
+```jsonc
+// tsconfig.json
+{
+  "compilerOptions": {
+    "plugins": [{
+      "name": "ty-fetch/plugin",
+      // Optional — point to specs manually. Without this, ty-fetch
+      // auto-discovers specs at /openapi.json, /.well-known/openapi.yaml, etc.
+      "specs": {
+        "api.mycompany.com": "https://api.mycompany.com/docs/openapi.json"
+      }
+    }]
+  }
+}
+```
+
+```ts
+import ty from "ty-fetch";
+
+// Fully typed — response, body, path params, query params, headers
+const { data, error } = await ty.post("https://api.mycompany.com/v1/users/{team}/invite", {
+  params: {
+    path: { team: "engineering" },
+    query: { notify: true },
+  },
+  body: { email: "jane@example.com", role: "admin" },
+  headers: { "x-api-key": process.env.API_KEY },
+});
+
+if (error) return console.error(error);
+console.log(data.user.id); // fully typed, autocomplete works
+```
+
+If your API serves an OpenAPI spec at `/openapi.json` (or any well-known path), ty-fetch finds it automatically. No config needed.
+
+---
+
+## 🤔 How does it work?
+
+ty-fetch is a **TypeScript language service plugin**. When you write a `ty.get("https://...")` call:
+
+1. 🔍 It extracts the domain from the URL
+2. 📡 Auto-discovers the OpenAPI spec (checks `/openapi.json`, `/.well-known/openapi.yaml`, etc.)
+3. 🏗️ Generates typed overloads on-the-fly — response types, query params, headers, everything
+4. ✅ Validates your API paths and suggests corrections for typos
 
-- **Path validation** — red squiggles for typos in API URLs, with "did you mean?" suggestions
-- **Typed responses** — response types generated from OpenAPI schemas, no manual `as` casts
-- **Typed request bodies** — body params validated against the spec
-- **Path & query params** — typed `params.path` and `params.query` based on the endpoint
-- **Autocomplete** — URL path completions inside string literals, filtered by HTTP method
-- **Hover info** — hover over a URL to see available methods and descriptions
+Types appear in your editor instantly. When the spec changes, types update automatically. No build step ever.
 
-Works as both a **TS language service plugin** (editor DX) and a **CLI** (CI validation).
+### Compared to other tools
 
-## Setup
+| | ty-fetch | [openapi-typescript](https://github.com/openapi-ts/openapi-typescript) | [openapi-fetch](https://github.com/openapi-ts/openapi-typescript/tree/main/packages/openapi-fetch) | [orval](https://github.com/orval-labs/orval) |
+|---|---|---|---|---|
+| **Codegen step** | None | `npx openapi-typescript ...` | Needs openapi-typescript first | `npx orval` |
+| **Build step** | None | Required | Required | Required |
+| **Generated files** | None | `.d.ts` files | `.d.ts` files | Full client |
+| **Spec changes** | Auto-updates | Re-run codegen | Re-run codegen | Re-run codegen |
+| **Auto-discovery** | Probes well-known paths | Manual | Manual | Manual |
+| **Editor integration** | TS plugin (autocomplete, hover, diagnostics) | Types only | Types only | Types only |
+| **Path validation** | Typo detection with suggestions | None | None | None |
+| **Runtime** | Thin fetch wrapper (~100 LOC) | None (types only) | Fetch wrapper | Axios/fetch client |
+
+---
+
+## 📦 Quick start
+
+### 1. Install
 
 ```bash
-npm install github:alnorris/ty-fetch
+npm install ty-fetch
 ```
 
-Add the plugin to your `tsconfig.json`:
+### 2. Add the plugin to tsconfig.json
 
 ```jsonc
 {
@@ -41,66 +95,43 @@ Add the plugin to your `tsconfig.json`:
 }
 ```
 
-In VS Code, make sure you're using the workspace TypeScript version (not the built-in one). Open the command palette and run **TypeScript: Select TypeScript Version** > **Use Workspace Version**.
-
-## Usage
-
-### The `ty-fetch` client
-
-A lightweight HTTP client (similar to [ky](https://github.com/sindresorhus/ky)) with typed methods:
+### 3. Start fetching
 
 ```ts
-import tf from "ty-fetch";
+import ty from "ty-fetch";
 
-// GET with typed response
-const customers = await tf.get("https://api.stripe.com/v1/customers").json();
+// If your API has a spec at /openapi.json — types just work
+const { data, error } = await ty.get("https://api.mycompany.com/v1/users");
+```
 
-// POST with typed body
-const customer = await tf.post("https://api.stripe.com/v1/customers", {
-  body: { name: "Jane Doe", email: "jane@example.com" },
-}).json();
+That's it. ✨
 
-// Path params
-const repo = await tf.get("https://api.github.com/repos/{owner}/{repo}", {
-  params: { path: { owner: "anthropics", repo: "claude-code" } },
-}).json();
+> **VS Code users:** Make sure you're using the workspace TypeScript version, not the built-in one. Command Palette → **TypeScript: Select TypeScript Version** → **Use Workspace Version**
 
-// Query params
-const pets = await tf.get("https://petstore3.swagger.io/api/v3/pet/findByStatus", {
-  params: { query: { status: "available" } },
-}).json();
-```
+Want to try it without setting up a project? Check out the [playground](./playground/).
 
-Response methods:
+---
 
-| Method | Returns |
-|---|---|
-| `.json()` | `Promise<T>` (typed from spec) |
-| `.text()` | `Promise<string>` |
-| `.blob()` | `Promise<Blob>` |
-| `.arrayBuffer()` | `Promise<ArrayBuffer>` |
-| `await` directly | `T` (same as `.json()`) |
+## 🔍 Spec discovery
 
-### CLI
+### Auto-discovery (zero config)
 
-Run validation in CI or from the terminal:
+When you call `ty.get("https://api.example.com/...")`, ty-fetch automatically probes the domain for an OpenAPI spec at these well-known paths:
 
-```bash
-npx ty-fetch                    # uses ./tsconfig.json
-npx ty-fetch tsconfig.json      # explicit path
-npx ty-fetch --verbose          # show spec fetching details
 ```
-
+/.well-known/openapi.json    /.well-known/openapi.yaml
+/openapi.json                /openapi.yaml
+/api/openapi.json            /docs/openapi.json
+/swagger.json                /api-docs/openapi.json
 ```
-example.ts:21:11 - error TF99001: Path '/v1/cutsomers' does not exist in Stripe API. Did you mean '/v1/customers'?
-example.ts:57:11 - error TF99001: Path '/pets' does not exist in Swagger Petstore. Did you mean '/pet'?
 
-2 error(s) found.
-```
+If any path returns a valid OpenAPI spec, types are generated automatically.
+
+**This means if your internal API serves a spec, ty-fetch will find it with zero configuration.**
 
-## Custom specs
+### Point to specific specs
 
-Map domains to local files or URLs in your tsconfig plugin config:
+For APIs that don't serve specs at standard paths, or for local spec files:
 
 ```jsonc
 {
@@ -109,7 +140,13 @@ Map domains to local files or URLs in your tsconfig plugin config:
       {
         "name": "ty-fetch/plugin",
         "specs": {
-          "api.internal.company.com": "./specs/internal-api.json",
+          // Remote spec URL
+          "api.mycompany.com": "https://api.mycompany.com/docs/v2/openapi.json",
+
+          // Local file (resolved relative to tsconfig)
+          "payments.internal.com": "./specs/payments.yaml",
+
+          // Third-party API
           "api.partner.com": "https://partner.com/openapi.json"
         }
       }
@@ -118,55 +155,326 @@ Map domains to local files or URLs in your tsconfig plugin config:
 }
 ```
 
-- **File paths** are resolved relative to the tsconfig directory
-- **URLs** are fetched over HTTPS
-- Custom specs override built-in defaults for the same domain
+Supported spec formats:
+
+| Format | Versions |
+|---|---|
+| **OpenAPI** | 3.0, 3.1 |
+| **Swagger** | 2.0 |
+| **File types** | JSON, YAML |
+| **Sources** | Local files, remote URLs, auto-discovered |
+
+Custom specs override auto-discovery for the same domain.
+
+---
+
+## 📖 API Reference
+
+### `import ty from "ty-fetch"`
+
+The default export is a pre-configured `TyFetch` instance.
+
+### HTTP Methods
+
+```ts
+ty.get(url, options?)      // GET
+ty.post(url, options?)     // POST
+ty.put(url, options?)      // PUT
+ty.patch(url, options?)    // PATCH
+ty.delete(url, options?)   // DELETE
+ty.head(url, options?)     // HEAD
+ty(url, options?)          // Custom method (set options.method)
+```
+
+All methods return `Promise<{ data, error, response }>`.
+
+When the plugin is active, the `url` parameter and all options are **typed from the OpenAPI spec**. Without the plugin, everything still works — just untyped.
+
+### Response Shape
+
+Every method returns `{ data, error, response }`:
+
+```ts
+const { data, error, response } = await ty.get("https://api.example.com/v1/users");
+
+if (error) {
+  // error is the parsed error body (typed if spec defines error responses)
+  console.error(error.message);
+  console.log(response.status); // raw Response always available
+  return;
+}
+
+// data is the parsed response body — fully typed from the spec
+console.log(data.users);
+```
+
+- **`data`** — parsed response body (`undefined` if error). JSON is auto-parsed, otherwise text.
+- **`error`** — parsed error body on non-2xx responses (`undefined` if success)
+- **`response`** — the raw `Response` object (always present)
 
-This works in both the editor plugin and the CLI.
+No `.json()` call needed — responses are parsed automatically.
 
-### Built-in specs
+### Options
 
-These APIs are supported out of the box (no config needed):
+```ts
+ty.post("https://api.example.com/v1/users/{team}/invite", {
+  // Path params — replaces {placeholders} in the URL
+  params: {
+    path: { team: "engineering" },
+    query: { notify: true, role: "admin" },
+  },
+
+  // JSON request body (auto-serialized, Content-Type set automatically)
+  body: { email: "jane@example.com", name: "Jane Doe" },
+
+  // Headers (typed from security schemes when plugin is active)
+  headers: { "x-api-key": "sk_live_..." },
+
+  // Prefix URL — prepended to the url argument
+  prefixUrl: "https://api.example.com",
+
+  // All standard fetch options are supported
+  signal: AbortSignal.timeout(5000),
+  cache: "no-store",
+  credentials: "include",
+});
+```
 
-| Domain | API | Paths |
+| Option | Type | Description |
 |---|---|---|
-| `api.stripe.com` | Stripe API | 414 |
-| `petstore3.swagger.io` | Swagger Petstore | 13 |
-| `api.github.com` | GitHub REST API | 551 |
+| `body` | `object` | JSON body — auto-serialized, `Content-Type: application/json` set |
+| `params.path` | `object` | Replaces `{placeholder}` segments in the URL |
+| `params.query` | `object` | Appended as `?key=value` query string |
+| `headers` | `object` | HTTP headers (typed from spec security schemes) |
+| `prefixUrl` | `string` | Prepended to the URL (useful with `create`/`extend`) |
 
-## How it works
+Plus all standard [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) options (`signal`, `cache`, `credentials`, `mode`, etc.)
 
-1. Plugin intercepts the TS language service (`getSemanticDiagnostics`, `getCompletionsAtPosition`, `getQuickInfoAtPosition`)
-2. Finds `fetch()` / `tf.get()` / `tf.post()` etc. calls with string literal URLs
-3. Extracts the domain and fetches the OpenAPI spec on-demand (cached after first fetch)
-4. Validates paths against the spec, suggests corrections via Levenshtein distance
-5. Generates typed overloads into `node_modules/ty-fetch/index.d.ts` using interface declaration merging — only for URLs actually used in your code
+### Creating Instances
+
+```ts
+// Create a pre-configured instance
+const api = ty.create({
+  prefixUrl: "https://api.mycompany.com",
+  headers: { "x-api-key": process.env.API_KEY },
+});
+
+// Now use short paths
+const { data } = await api.get("/v1/users");
+const { data: user } = await api.post("/v1/users", {
+  body: { name: "Jane" },
+});
+
+// Extend an existing instance (merges options)
+const adminApi = api.extend({
+  headers: { "x-admin-token": process.env.ADMIN_TOKEN },
+});
+```
 
-Spec fetching is async. On first encounter of a domain, the plugin fires a background fetch and returns no extra diagnostics. When the spec arrives, `refreshDiagnostics()` triggers the editor to re-check. This follows the same pattern as [graphqlsp](https://github.com/0no-co/graphqlsp).
+### Middleware
 
-## Architecture
+Add middleware to intercept requests and responses:
 
+```ts
+import ty from "ty-fetch";
+
+// Add auth header to every request
+ty.use({
+  onRequest(request) {
+    request.headers.set("Authorization", `Bearer ${getToken()}`);
+    return request;
+  },
+});
+
+// Log all responses
+ty.use({
+  onResponse(response) {
+    console.log(`${response.status} ${response.url}`);
+    return response;
+  },
+});
+
+// Retry on 401
+ty.use({
+  async onResponse(response) {
+    if (response.status === 401) {
+      await refreshToken();
+      return fetch(response.url, { headers: { Authorization: `Bearer ${getToken()}` } });
+    }
+    return response;
+  },
+});
 ```
-src/
-  plugin/index.ts      TS language service plugin (diagnostics, completions, hover)
-  cli/index.ts         CLI entry point for CI validation
-  core/                Shared logic (URL parsing, spec cache, path matching, body validation)
-  generate-types.ts    OpenAPI schema -> TypeScript type declarations
-test-project/          Example project using the plugin
-test/                  Unit tests
+
+| Hook | Signature | Description |
+|---|---|---|
+| `onRequest` | `(request: Request) => Request \| RequestInit \| void` | Modify the request before it's sent |
+| `onResponse` | `(response: Response) => Response \| void` | Modify or replace the response |
+
+Both hooks can be async. Middleware runs in the order it's added.
+
+### Streaming
+
+Stream SSE (Server-Sent Events), NDJSON, or raw text responses:
+
+```ts
+// Server-Sent Events (e.g. OpenAI, Anthropic streaming APIs)
+for await (const event of ty.stream("https://api.example.com/v1/chat", {
+  method: "POST",
+  body: { prompt: "Hello", stream: true },
+})) {
+  console.log(event); // each parsed SSE event
+}
+
+// NDJSON streaming
+for await (const line of ty.stream("https://api.example.com/v1/logs")) {
+  console.log(line); // each parsed JSON line
+}
+```
+
+Auto-detects the format from `Content-Type`:
+- `text/event-stream` → SSE (parses `data:` lines, stops at `[DONE]`)
+- `application/x-ndjson` / `application/jsonl` → NDJSON (parses each line as JSON)
+- Anything else → raw text chunks
+
+### Plugin Features (editor only)
+
+When the TS plugin is active, you get these extras on top of the runtime API:
+
+| Feature | What it does |
+|---|---|
+| **Typed responses** | `data` is the actual response type from the spec, not `any` |
+| **Typed body** | `body` option is validated against the spec's request body schema |
+| **Typed query params** | `params.query` keys and types from the spec's parameter definitions |
+| **Typed path params** | `params.path` keys from `{placeholder}` segments |
+| **Typed headers** | Required headers from the spec's security schemes |
+| **Path validation** | Red squiggles on invalid API paths with "did you mean?" |
+| **Autocomplete** | URL completions inside string literals, filtered by HTTP method |
+| **Hover docs** | Hover over a URL to see available methods and descriptions |
+| **JSDoc** | Property descriptions from the spec appear in hover tooltips |
+| **Example inference** | Types inferred from response `example` when `schema` is missing |
+
+---
+
+## 🖥️ CI / Type checking
+
+### Why not just `tsc`?
+
+`tsc` doesn't run TypeScript language service plugins — it only sees the base `any` types. Your code will compile, but you won't get type errors for wrong API paths or mismatched params.
+
+For CI, you have two options:
+
+### Option 1: ty-fetch CLI (recommended)
+
+Validates API paths against OpenAPI specs — catches typos and invalid endpoints:
+
+```bash
+npx ty-fetch                    # uses ./tsconfig.json
+npx ty-fetch tsconfig.json      # explicit path
+npx ty-fetch --verbose          # show spec fetching details
+```
+
+```
+src/api.ts:21:11 - error TF99001: Path '/v1/uusers' does not exist.
+                   Did you mean '/v1/users'?
+
+1 error(s) found.
+```
+
+Add to your CI pipeline:
+
+```yaml
+# GitHub Actions
+- run: npx ty-fetch tsconfig.json
+```
+
+### Option 2: ESLint plugin (coming soon)
+
+If you prefer eslint over a separate CLI, you can use the ty-fetch eslint rule:
+
+```bash
+npm install -D eslint-plugin-ty-fetch
+```
+
+```js
+// eslint.config.mjs
+import tyFetch from "eslint-plugin-ty-fetch";
+
+export default [tyFetch.configs.recommended];
+```
+
+This runs the same validation as the CLI but inside your existing eslint pipeline.
+
+> **Note:** The eslint plugin is not yet published. For now, use the CLI.
+
+---
+
+## 🌍 Runtime compatibility
+
+ty-fetch is a thin wrapper around the standard Fetch API. It works anywhere `fetch` is available:
+
+| Runtime | Supported |
+|---|---|
+| **Node.js** | 18+ (native fetch) |
+| **Bun** | ✅ |
+| **Deno** | ✅ |
+| **Browsers** | ✅ (all modern browsers) |
+| **Cloudflare Workers** | ✅ |
+
+The TS plugin (type generation) runs in your editor's TypeScript server — it doesn't affect runtime behavior.
+
+---
+
+## ❓ FAQ
+
+<details>
+<summary><strong>Why do I see <code>any</code> types instead of typed responses?</strong></summary>
+
+The TS plugin needs to be active. Check:
+1. Plugin is in `tsconfig.json` under `compilerOptions.plugins`
+2. In VS Code, you're using the **workspace** TypeScript version (not the built-in one)
+3. Restart the TS server after config changes (Command Palette → "TypeScript: Restart TS Server")
+4. The API's OpenAPI spec is reachable (try `curl https://your-api.com/openapi.json`)
+</details>
+
+<details>
+<summary><strong>Why doesn't <code>tsc</code> catch type errors?</strong></summary>
+
+`tsc` doesn't run language service plugins — it only sees the base `any` types. Use the ty-fetch CLI for CI validation: `npx ty-fetch tsconfig.json`
+</details>
+
+<details>
+<summary><strong>Does ty-fetch work without the plugin?</strong></summary>
+
+Yes. The runtime client works independently — you get `{ data, error, response }` back from every call. You just won't get typed responses or path validation. It's a perfectly usable HTTP client on its own.
+</details>
+
+<details>
+<summary><strong>What if my API doesn't serve an OpenAPI spec?</strong></summary>
+
+You can point to a local spec file in your tsconfig:
+```jsonc
+"specs": { "api.mycompany.com": "./specs/my-api.yaml" }
 ```
+</details>
+
+<details>
+<summary><strong>How big is this package?</strong></summary>
+
+The runtime client (`index.js`) is ~100 lines. The plugin code ships in `dist/` but only runs inside the TS server, not in your bundle.
+</details>
+
+---
 
-## Development
+## 🧪 Development
 
 ```bash
 npm run build          # compile TypeScript
 npm run watch          # compile in watch mode
-npm test               # run unit tests
+npm test               # run unit tests (132 tests)
+npm run check          # lint with biome + eslint
 ```
 
-To test the editor experience:
+## License
 
-1. Open `test-project/` in VS Code
-2. Select the workspace TypeScript version
-3. Restart the TS server (`TypeScript: Restart TS Server`)
-4. Edit `test-project/example.ts` and observe diagnostics/completions
+MIT

package/base.d.ts

@@ -17,29 +17,36 @@ export interface Options<
   prefixUrl?: string;
 }
 
-export interface ResponsePromise<T = unknown> extends PromiseLike<T> {
-  json(): Promise<T>;
-  text(): Promise<string>;
-  blob(): Promise<Blob>;
-  arrayBuffer(): Promise<ArrayBuffer>;
-  formData(): Promise<FormData>;
+export type FetchResult<TData = unknown, TError = unknown> =
+  | { data: TData; error: undefined; response: Response }
+  | { data: undefined; error: TError; response: Response };
+
+export interface Middleware {
+  onRequest?: (request: Request) => Request | RequestInit | void | Promise<Request | RequestInit | void>;
+  onResponse?: (response: Response) => Response | void | Promise<Response | void>;
+}
+
+export interface StreamResult<T = unknown> extends AsyncIterable<T> {
+  response: Promise<Response>;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type BaseOptions = Options<any, Record<string, any>, Record<string, any>>;
 
 export interface TyFetch {
-  (url: string, options?: BaseOptions): ResponsePromise<any>;
-  get(url: string, options?: BaseOptions): ResponsePromise<any>;
-  post(url: string, options?: BaseOptions): ResponsePromise<any>;
-  put(url: string, options?: BaseOptions): ResponsePromise<any>;
-  patch(url: string, options?: BaseOptions): ResponsePromise<any>;
-  delete(url: string, options?: BaseOptions): ResponsePromise<any>;
-  head(url: string, options?: BaseOptions): ResponsePromise<any>;
+  (url: string, options?: BaseOptions): Promise<FetchResult<any>>;
+  get(url: string, options?: BaseOptions): Promise<FetchResult<any>>;
+  post(url: string, options?: BaseOptions): Promise<FetchResult<any>>;
+  put(url: string, options?: BaseOptions): Promise<FetchResult<any>>;
+  patch(url: string, options?: BaseOptions): Promise<FetchResult<any>>;
+  delete(url: string, options?: BaseOptions): Promise<FetchResult<any>>;
+  head(url: string, options?: BaseOptions): Promise<FetchResult<any>>;
+  stream(url: string, options?: BaseOptions): StreamResult;
   create(defaults?: BaseOptions): TyFetch;
   extend(defaults?: BaseOptions): TyFetch;
+  use(middleware: Middleware): TyFetch;
   HTTPError: typeof HTTPError;
 }
 
-declare const tf: TyFetch;
-export default tf;
+declare const ty: TyFetch;
+export default ty;