ty-fetch 0.0.2-beta.9 → 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,51 +1,91 @@
-# ty-fetch
+<p align="center">
+  <img src="logo.png" alt="ty-fetch" width="350" />
+</p>
 
-Automatic TypeScript types for any REST API. No codegen step, no manual types — just install, write fetch calls, and get full type safety from OpenAPI specs.
+<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)
+
+**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.**
+
+```bash
+npm install ty-fetch
+```
+
+```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"
+      }
+    }]
+  }
+}
+```
 
-// Fully typed response — no codegen, no manual types
-const customers = await tf.get("https://api.stripe.com/v1/customers").json();
-customers.data // Customer[] — autocomplete works
+```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 },
+});
 
-tf.get("https://api.stripe.com/v1/cutsomers");
-//                                  ~~~~~~~~~~
-// Error: Path '/v1/cutsomers' does not exist in Stripe API.
-//        Did you mean '/v1/customers'?
+if (error) return console.error(error);
+console.log(data.user.id); // fully typed, autocomplete works
 ```
 
-## How is this different?
+If your API serves an OpenAPI spec at `/openapi.json` (or any well-known path), ty-fetch finds it automatically. No config needed.
 
-Most OpenAPI tools require a **codegen step** — you run a command, it generates a client, you import from the generated code. When the spec changes, you regenerate.
+---
 
-ty-fetch has **no codegen**. The TypeScript language service plugin reads OpenAPI specs and generates typed overloads on-the-fly as you write code. Types appear instantly in your editor. You write plain fetch calls with real URLs.
+## 🤔 How does it work?
 
-## Features
+ty-fetch is a **TypeScript language service plugin**. When you write a `ty.get("https://...")` call:
 
-- **Zero codegen** — types are generated on-the-fly by a TS plugin, not a build step
-- **Typed responses** — `.json()` returns the actual response type from the spec
-- **Typed request bodies** — body params validated against the spec
-- **Typed path & query params** — `params.path` and `params.query` based on the endpoint
-- **Typed headers** — required headers (API keys, auth) from security schemes
-- **Path validation** — red squiggles for typos, with "did you mean?" suggestions
-- **Autocomplete** — URL path completions inside string literals, filtered by HTTP method
-- **Hover info** — hover over a URL to see available methods and descriptions
-- **JSDoc descriptions** — property descriptions from the spec show up in hover tooltips
-- **Auto-discovery** — probes well-known paths (`/openapi.json`, `/.well-known/openapi.yaml`, etc.) when no spec is configured
-- **YAML support** — specs can be JSON or YAML, local files or remote URLs
-- **Example inference** — generates types from response `example` when `schema` is missing
-- **On-demand** — only fetches specs and generates types for APIs you actually 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
 
-Works as both a **TS language service plugin** (editor) and a **CLI** (CI).
+Types appear in your editor instantly. When the spec changes, types update automatically. No build step ever.
 
-## Setup
+### Compared to other tools
+
+| | 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 ty-fetch
 ```
 
-Add the plugin to your `tsconfig.json`:
+### 2. Add the plugin to tsconfig.json
 
 ```jsonc
 {
@@ -55,78 +95,43 @@ Add the plugin to your `tsconfig.json`:
 }
 ```
 
-In VS Code, use the workspace TypeScript version: command palette > **TypeScript: Select TypeScript Version** > **Use Workspace Version**.
-
-That's it. Start writing `tf.get("https://...")` and types appear automatically.
-
-## Usage
+### 3. Start fetching
 
 ```ts
-import tf from "ty-fetch";
-
-// GET with typed response
-const customers = await tf.get("https://api.stripe.com/v1/customers").json();
-
-// POST with typed body
-const customer = await tf.post("https://api.stripe.com/v1/customers", {
-  body: { name: "Jane Doe", email: "jane@example.com" },
-}).json();
+import ty from "ty-fetch";
 
-// Path params
-const repo = await tf.get("https://api.github.com/repos/{owner}/{repo}", {
-  params: { path: { owner: "anthropics", repo: "claude-code" } },
-}).json();
-
-// Query params
-const pets = await tf.get("https://petstore3.swagger.io/api/v3/pet/findByStatus", {
-  params: { query: { status: "available" } },
-}).json();
-
-// Headers (typed from security schemes)
-const data = await tf.get("https://api.scrapecreators.com/v1/reddit/search", {
-  params: { query: { query: "typescript" } },
-  headers: { "x-api-key": process.env.API_KEY },
-}).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");
 ```
 
-Response methods:
+That's it. ✨
 
-| Method | Returns |
-|---|---|
-| `.json()` | `Promise<T>` (typed from spec) |
-| `.text()` | `Promise<string>` |
-| `.blob()` | `Promise<Blob>` |
-| `.arrayBuffer()` | `Promise<ArrayBuffer>` |
-| `await` directly | `T` (same as `.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**
 
-## Spec configuration
+Want to try it without setting up a project? Check out the [playground](./playground/).
 
-### Built-in specs (no config needed)
+---
 
-These APIs are typed out of the box:
+## 🔍 Spec discovery
 
-| Domain | API |
-|---|---|
-| `api.stripe.com` | Stripe API |
-| `api.github.com` | GitHub REST API |
-| `petstore3.swagger.io` | Swagger Petstore |
+### Auto-discovery (zero config)
 
-### Auto-discovery
+When you call `ty.get("https://api.example.com/...")`, ty-fetch automatically probes the domain for an OpenAPI spec at these well-known paths:
 
-For unknown domains, ty-fetch probes well-known paths automatically:
+```
+/.well-known/openapi.json    /.well-known/openapi.yaml
+/openapi.json                /openapi.yaml
+/api/openapi.json            /docs/openapi.json
+/swagger.json                /api-docs/openapi.json
+```
 
-- `/.well-known/openapi.json`, `.yaml`, `.yml`
-- `/openapi.json`, `.yaml`, `.yml`
-- `/api/openapi.json`, `.yaml`
-- `/docs/openapi.json`, `.yaml`
-- `/swagger.json`
-- `/api-docs/openapi.json`
+If any path returns a valid OpenAPI spec, types are generated automatically.
 
-If any of these return 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 remote URLs in your tsconfig:
+For APIs that don't serve specs at standard paths, or for local spec files:
 
 ```jsonc
 {
@@ -135,7 +140,13 @@ Map domains to local files or remote URLs in your tsconfig:
       {
         "name": "ty-fetch/plugin",
         "specs": {
-          "api.internal.company.com": "./specs/internal-api.yaml",
+          // 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"
         }
       }
@@ -144,14 +155,218 @@ Map domains to local files or remote URLs in your tsconfig:
 }
 ```
 
-- File paths are resolved relative to the tsconfig directory
-- Supports JSON and YAML specs
-- Custom specs override built-in defaults for the same domain
-- Works in both the editor plugin and the CLI
+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)
+
+No `.json()` call needed — responses are parsed automatically.
+
+### Options
+
+```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",
+});
+```
+
+| Option | Type | Description |
+|---|---|---|
+| `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`) |
+
+Plus all standard [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) options (`signal`, `cache`, `credentials`, `mode`, etc.)
+
+### 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 },
+});
+```
+
+### Middleware
+
+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;
+  },
+});
+```
+
+| 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)
 
-## CLI
+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 |
 
-Validate API calls in CI:
+---
+
+## 🖥️ 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
@@ -160,27 +375,106 @@ npx ty-fetch --verbose          # show spec fetching details
 ```
 
 ```
-src/api.ts:21:11 - error TF99001: Path '/v1/cutsomers' does not exist in Stripe API. Did you mean '/v1/customers'?
+src/api.ts:21:11 - error TF99001: Path '/v1/uusers' does not exist.
+                   Did you mean '/v1/users'?
 
 1 error(s) found.
 ```
 
-## How it works
+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** | ✅ |
 
-1. The TS plugin intercepts the language service (`getSemanticDiagnostics`, `getCompletionsAtPosition`, `getQuickInfoAtPosition`)
-2. Finds `tf.get()` / `tf.post()` / `fetch()` 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` via interface declaration merging — only for URLs actually used in your code
+The TS plugin (type generation) runs in your editor's TypeScript server — it doesn't affect runtime behavior.
 
-Spec fetching is async. On first encounter, the plugin fires a background fetch and returns no extra diagnostics. When the spec arrives, `refreshDiagnostics()` re-checks the file. Same pattern as [graphqlsp](https://github.com/0no-co/graphqlsp).
+---
 
-Types are generated **only for endpoints you actually use** — not the entire spec. This keeps overload counts low and TypeScript fast.
+## ❓ FAQ
 
-## Development
+<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
 
 ```bash
 npm run build          # compile TypeScript
 npm run watch          # compile in watch mode
-npm test               # run unit tests (74 tests)
+npm test               # run unit tests (132 tests)
+npm run check          # lint with biome + eslint
 ```
+
+## License
+
+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;