Improve YAML documentation with Bun.YAML.stringify and TypeScript typing

- Add Bun.YAML.stringify() documentation with examples using (null, 2) for spacing
- Document space parameter: 2 for readable format, 0 for condensed inline notation
- Add TypeScript section in Module Import explaining manual .d.ts requirement
- Clarify that unlike JSON, TypeScript doesn't automatically type YAML imports

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: Claude Bot

docs/guides/runtime/import-yaml.mdx

@@ -77,7 +77,11 @@ console.log(data.hobbies); // => ["reading", "coding"]
 
 ## TypeScript Support
 
-To add TypeScript support for your YAML imports, create a declaration file with `.d.ts` appended to the YAML filename (e.g., `config.yaml` → `config.yaml.d.ts`);
+Unlike JSON files which TypeScript handles automatically, YAML files require manual type definitions. You have two options for adding TypeScript support:
+
+### Option 1: Per-File Declaration (Recommended)
+
+Create a declaration file with `.d.ts` appended to the YAML filename (e.g., `config.yaml` → `config.yaml.d.ts`):
 
 ```ts config.yaml.d.ts icon="/icons/typescript.svg"
 const contents: {
@@ -99,6 +103,26 @@ const contents: {
 export = contents;
 ```
 
+This approach gives you precise types for each YAML file.
+
+### Option 2: Global Declaration
+
+For a global type definition (applies to all `.yaml` and `.yml` files), create a declaration file anywhere in your project:
+
+```ts global.d.ts icon="/icons/typescript.svg"
+declare module "*.yaml" {
+  const content: any;
+  export default content;
+}
+
+declare module "*.yml" {
+  const content: any;
+  export default content;
+}
+```
+
+**Note:** TypeScript doesn't automatically type YAML imports like it does for JSON. You must explicitly add type definitions using one of the methods above.
+
 ---
 
 See [Docs > API > YAML](https://bun.com/docs/api/yaml) for complete documentation on YAML support in Bun.

docs/runtime/yaml.mdx

@@ -23,6 +23,47 @@ Bun's YAML parser currently passes over 90% of the official YAML test suite. Whi
 
 Parse a YAML string into a JavaScript object.
 
+### `Bun.YAML.stringify()`
+
+Convert a JavaScript object into a YAML string.
+
+```ts
+import { YAML } from "bun";
+
+const obj = {
+  name: "John Doe",
+  age: 30,
+  email: "[email protected]",
+  hobbies: ["reading", "coding", "hiking"]
+};
+
+const yaml = Bun.YAML.stringify(obj, null, 2);
+console.log(yaml);
+// name: John Doe
+// age: 30
+// email: [email protected]
+// hobbies:
+//   - reading
+//   - coding
+//   - hiking
+```
+
+The signature is similar to `JSON.stringify()`:
+
+```ts
+Bun.YAML.stringify(value, replacer?, space?)
+```
+
+The `space` parameter controls indentation (default: 2). With `space: 0`, YAML uses inline notation making output more condensed than JSON:
+
+```ts
+const compact = Bun.YAML.stringify(obj, null, 0);
+// name: John Doe
+// age: 30
+// email: [email protected]
+// hobbies: [reading, coding, hiking]
+```
+
 ```ts
 import { YAML } from "bun";
 const text = `
@@ -193,6 +234,30 @@ const { database, redis } = require("./config.yaml");
 console.log(database.port); // 5432
 ```
 
+### TypeScript
+
+Unlike JSON files, TypeScript doesn't automatically type YAML imports. Add type definitions by creating a `.d.ts` file with the same name as your YAML file:
+
+```ts config.yaml.d.ts icon="/icons/typescript.svg"
+const contents: {
+  database: {
+    host: string;
+    port: number;
+    name: string;
+  };
+  server: {
+    port: number;
+    timeout: number;
+  };
+  features: {
+    auth: boolean;
+    rateLimit: boolean;
+  };
+};
+
+export = contents;
+```
+
 ---
 
 ## Hot Reloading with YAML
@@ -435,6 +500,49 @@ if (parseConfig(migrations).autoRun === "true") {
 }
 ```
 
+### Generating YAML Files
+
+You can use `Bun.YAML.stringify()` to programmatically create YAML configuration files:
+
+```ts generate-config.ts icon="/icons/typescript.svg"
+import { YAML } from "bun";
+
+const config = {
+  server: {
+    port: 3000,
+    host: "localhost",
+  },
+  database: {
+    type: "postgres",
+    host: "localhost",
+    port: 5432,
+    name: "myapp",
+    pool: {
+      min: 2,
+      max: 10,
+    },
+  },
+  features: {
+    auth: true,
+    rateLimit: true,
+    analytics: false,
+  },
+};
+
+// Generate readable YAML with 2-space indentation
+const yaml = Bun.YAML.stringify(config, null, 2);
+await Bun.write("config.yaml", yaml);
+
+console.log("Generated config.yaml:");
+console.log(yaml);
+```
+
+This is particularly useful for:
+- Generating configuration files from templates
+- Exporting settings from your application
+- Creating config files for CI/CD pipelines
+- Building development tools that output YAML
+
 ### Bundler Integration
 
 When you import YAML files in your application and bundle it with Bun, the YAML is parsed at build time and included as a JavaScript module: