diff --git a/fern/docs.yml b/fern/docs.yml
index c6fc612..6104e06 100644
--- a/fern/docs.yml
+++ b/fern/docs.yml
@@ -8,7 +8,7 @@ ai-search:
location:
- docs
-title: Plant Store
+title: Fern Docs Starter
layout:
searchbar-placement: header
@@ -19,9 +19,6 @@ tabs:
home:
display-name: Docs
icon: home
- guides:
- display-name: Guides
- icon: book
API Reference:
display-name: API Reference
icon: puzzle
@@ -29,75 +26,73 @@ tabs:
navigation:
- tab: home
layout:
- - section: Get Started
+ - section: Get started
contents:
- page: Welcome
path: docs/pages/welcome.mdx
- - tab: guides
- layout:
- - section: Get started
- contents:
- - page: Overview
- path: docs/pages/get-started/overview.mdx
- icon: fa-duotone fa-book-open
- - page: Quickstart
- path: docs/pages/get-started/quickstart.mdx
- icon: fa-duotone fa-rocket
- - section: Capabilities
- contents:
- - page: Plant management
- path: docs/pages/capabilities/plant-management.mdx
- icon: fa-duotone fa-seedling
- - page: Order processing
- path: docs/pages/capabilities/order-processing.mdx
- icon: fa-duotone fa-cart-shopping
- - page: Customer management
- path: docs/pages/capabilities/customer-management.mdx
- icon: fa-duotone fa-users
- - page: Inventory tracking
- path: docs/pages/capabilities/inventory-tracking.mdx
- icon: fa-duotone fa-boxes-stacked
- - section: Tutorials
- contents:
- - page: Searching for plants
- path: docs/pages/tutorials/searching-plants.mdx
- icon: fa-duotone fa-magnifying-glass
- - page: Creating your first order
- path: docs/pages/tutorials/first-order-tutorial.mdx
- icon: fa-duotone fa-bag-shopping
- - page: Managing plant inventory
- path: docs/pages/tutorials/inventory-tutorial.mdx
- icon: fa-duotone fa-clipboard-list
+ icon: fa-duotone fa-house
+ - page: Edit your docs
+ path: docs/pages/editing-your-docs.mdx
+ icon: fa-duotone fa-pen-to-square
+ - page: Write content
+ path: docs/pages/writing-content.mdx
+ icon: fa-duotone fa-file-lines
+ - page: Set up navigation
+ path: docs/pages/navigation.mdx
+ icon: fa-duotone fa-sitemap
+ - page: Customize your docs
+ path: docs/pages/customization.mdx
+ icon: fa-duotone fa-palette
+ - page: Support
+ path: docs/pages/support.mdx
+ icon: fa-duotone fa-headset
- section: Changelog
contents:
- changelog: docs/changelog
- tab: API Reference
layout:
- - api: API Reference
+ - section: Overview
+ contents:
+ - page: API reference
+ path: docs/pages/api-reference-overview.mdx
+ icon: fa-duotone fa-book
+ - api: Plant Store API
+ layout:
+ - section: Plants
+ referenced-packages:
+ - plant
+ contents: []
+ - section: Users
+ referenced-packages:
+ - user
+ contents: []
navbar-links:
- type: minimal
text: Fork this repo
url: https://github.com/fern-api/docs-starter
- type: filled
- text: Get a demo
- url: https://buildwithfern.com/contact?utm_campaign=demo&utm_medium=plantstore&utm_source=navbar
+ text: Dashboard
+ url: https://dashboard.buildwithfern.com
- type: github
value: https://github.com/fern-api/fern
colors:
- accentPrimary:
- dark: "#81C784"
- light: "#1B5E20"
+ accent-primary:
+ dark: "#70E155"
+ light: "#008700"
+ background:
+ dark: "#111113"
+ light: "#FFFFFF"
theme:
page-actions: toolbar
footer-nav: minimal
logo:
- dark: docs/assets/logo-dark.svg
- light: docs/assets/logo-light.svg
+ dark: docs/assets/logo.svg
+ light: docs/assets/logo.svg
height: 20
- href: https://buildwithfern.com/?utm_campaign=demo&utm_medium=plantstore&utm_source=logo
+ href: https://buildwithfern.com
favicon: docs/assets/favicon.svg
diff --git a/fern/docs/assets/logo.svg b/fern/docs/assets/logo.svg
new file mode 100644
index 0000000..2d280fe
--- /dev/null
+++ b/fern/docs/assets/logo.svg
@@ -0,0 +1,11 @@
+
diff --git a/fern/docs/pages/api-reference-overview.mdx b/fern/docs/pages/api-reference-overview.mdx
new file mode 100644
index 0000000..42aa654
--- /dev/null
+++ b/fern/docs/pages/api-reference-overview.mdx
@@ -0,0 +1,81 @@
+---
+title: API reference
+subtitle: Interactive documentation generated from your API specification
+slug: api-reference
+---
+
+Fern automatically generates interactive API reference documentation from your API specification. This starter template includes a sample Plant Store API to demonstrate the feature.
+
+## Supported specifications
+
+Fern supports multiple API specification formats:
+
+| Format | Description | Documentation |
+|--------|-------------|---------------|
+| **OpenAPI** | The most widely used REST API specification format (versions 2.0, 3.0, and 3.1) | [OpenAPI docs](https://buildwithfern.com/learn/api-definitions/openapi/overview) |
+| **AsyncAPI** | For event-driven and message-based APIs | [AsyncAPI docs](https://buildwithfern.com/learn/api-definitions/asyncapi) |
+| **gRPC** | Protocol buffer definitions for gRPC services | [gRPC docs](https://buildwithfern.com/learn/api-definitions/protobuf) |
+
+## How it works
+
+Place your API specification file in the `fern/` directory and reference it in your `docs.yml` navigation:
+
+```yaml title="docs.yml"
+navigation:
+ - section: Documentation
+ contents:
+ - page: Overview
+ path: docs/pages/overview.mdx
+ - api: API Reference
+```
+
+Fern parses your specification and generates:
+
+- Endpoint documentation with request/response schemas
+- Interactive API Explorer for testing endpoints
+- Code snippets in multiple languages
+- Type definitions and examples
+
+## API Explorer
+
+The API Explorer lets users test API endpoints directly in the documentation. Users can fill in parameters, send requests, and see responses without leaving the page.
+
+
+For advanced API Explorer features like auto-populating API keys, see the [API Explorer documentation](https://buildwithfern.com/learn/docs/api-references/api-explorer/overview).
+
+
+## Customizing the API reference
+
+Control how your API reference appears using the `api` configuration in `docs.yml`:
+
+```yaml title="docs.yml"
+navigation:
+ - api: API Reference
+ api-name: plantstore
+ paginated: true
+```
+
+You can also add custom content to API reference pages, organize endpoints into groups, customize section names, and control which endpoints are visible.
+
+
+For detailed customization options, see the [API reference documentation](https://buildwithfern.com/learn/docs/api-references/generate-api-ref).
+
+
+## SDK code snippets
+
+If you generate SDKs with Fern, code snippets automatically appear in your API reference showing how to call each endpoint using your SDK:
+
+```yaml title="generators.yml"
+groups:
+ python-sdk:
+ generators:
+ - name: fernapi/fern-python-sdk
+ version: 4.3.1
+ output:
+ location: pypi
+ package-name: plantstore
+```
+
+
+For more information on SDK generation, see the [SDK documentation](https://buildwithfern.com/learn/sdks/overview/introduction).
+
diff --git a/fern/docs/pages/capabilities/customer-management.mdx b/fern/docs/pages/capabilities/customer-management.mdx
deleted file mode 100644
index e4a2b1f..0000000
--- a/fern/docs/pages/capabilities/customer-management.mdx
+++ /dev/null
@@ -1,77 +0,0 @@
----
-title: Customer management
-subtitle: Build lasting customer relationships with comprehensive profile and preference tracking
-slug: customer-management
----
-
-## Overview
-
-The Plant Store API's customer management capabilities help you build and maintain customer relationships through detailed profiles, preferences, and purchase history. Use it to create and manage customer profiles, track order history, manage multiple shipping addresses, store communication preferences, and build loyalty programs.
-
-
-
- Learn how to create customers as part of the order flow.
-
-
- Explore customer endpoints and schemas.
-
-
-
-## Customer data types
-
-Different types of customer data serve different purposes in your system.
-
-| Data type | What it includes | Primary use |
-|-----------|------------------|-------------|
-| **Identity** | Name, email, phone, customer ID | Order fulfillment, authentication |
-| **Preferences** | Email/SMS settings, language, timezone | Marketing, communication |
-| **Transactional** | Order history, total spend, returns | Loyalty programs, segmentation |
-| **Addresses** | Multiple shipping addresses, labels | Faster checkout, gift shipping |
-
-
-Only collect data you'll actually use. More data means more liability and compliance requirements. Keep it minimal and purposeful.
-
-
-## Address management
-
-Customers often ship to multiple locations like home, office, or gift recipients. Support multiple saved addresses with labels like "Home" or "Mom's house" for easy selection. Validate addresses at entry to reduce shipping errors and allow customers to set a default shipping address for faster checkout.
-
-
-Address validation during input prevents expensive shipping errors. Most shipping carriers provide free address validation APIs.
-
-
-## Privacy and compliance
-
-Customer data requires careful handling to maintain trust and meet legal requirements. Encrypt sensitive data at rest and in transit, support GDPR data export and deletion requests, and implement secure password requirements. Log all access to customer data for audit trails.
-
-| Regulation | Applies to | Key requirement |
-|------------|------------|-----------------|
-| GDPR | EU customers | Right to access, export, and delete data |
-| CCPA | California customers | Right to know what data is collected |
-| CAN-SPAM | Email marketing | Easy unsubscribe, accurate sender info |
-
-Retain customer data only as long as it's useful and compliant. Active customers can be kept indefinitely, inactive customers for 3-7 years, and deleted accounts only what's legally required for tax and transaction records.
-
-
-Never commit customer data or API keys to version control. Use environment variables and secrets management instead.
-
-
-## Customer segmentation
-
-Group customers for targeted engagement and personalized experiences.
-
-| Segment by | Example groups | Use case |
-|------------|----------------|----------|
-| **Purchase behavior** | High-value, frequent, one-time, at-risk | Loyalty rewards, win-back campaigns |
-| **Product preference** | Indoor enthusiasts, succulent collectors | Product recommendations |
-| **Engagement** | Highly engaged, moderate, dormant | Email frequency, re-engagement |
-
-Segmentation enables more effective marketing by tailoring messages to customer interests and behavior patterns.
diff --git a/fern/docs/pages/capabilities/inventory-tracking.mdx b/fern/docs/pages/capabilities/inventory-tracking.mdx
deleted file mode 100644
index 15696f8..0000000
--- a/fern/docs/pages/capabilities/inventory-tracking.mdx
+++ /dev/null
@@ -1,93 +0,0 @@
----
-title: Inventory tracking
-subtitle: Track plant stock levels in real-time with automated alerts and reservations
-slug: inventory-tracking
----
-
-## Overview
-
-The Plant Store API's inventory tracking capabilities help you maintain accurate stock levels and prevent overselling. Use it to track on-hand, reserved, and available quantities, reserve inventory when orders are placed, set up automatic low-stock alerts, view inventory history and audit trails, and manage stock across multiple locations.
-
-
-
- Learn how to track and update your plant stock.
-
-
- Explore inventory endpoints and schemas.
-
-
-
-## Inventory states
-
-Inventory isn't just a single number. Plants exist in different states throughout the order and fulfillment process.
-
-| State | Definition | Formula |
-|-------|------------|---------|
-| **On-hand** | Physical count in your possession | Actual count from warehouse |
-| **Reserved** | Committed to pending orders | Sum of active order reservations |
-| **Available** | Stock available for new orders | On-hand - Reserved - Damaged |
-| **In-transit** | Ordered from suppliers, not yet received | Active purchase orders |
-
-
-Update inventory in real-time, not in batches. Delays between order creation and inventory updates cause overselling.
-
-
-## Reservation strategy
-
-Reserve inventory when an order is created (not just when paid) to prevent two customers from buying the last plant simultaneously. Set expiration times for unpaid orders—typically 15-30 minutes—and release reservations automatically if payment fails or times out. Convert reservations to permanent deductions when the order ships.
-
-
-Most payment processors complete checkout within 15 minutes. Setting reservation expiration to 15-30 minutes balances preventing overselling with not holding stock unnecessarily.
-
-
-## Low-stock alerts
-
-Set reorder points based on supplier lead time and sales velocity to ensure you never run out of popular plants.
-
-**Reorder point formula:** `(Lead time in days × Daily sales) + Safety stock`
-
-| Component | Example | Purpose |
-|-----------|---------|---------|
-| Lead time | 7 days | How long to get new stock from supplier |
-| Daily sales | 2 plants/day | Average sales velocity |
-| Safety stock | 5 plants | Buffer for demand spikes or delays |
-| **Reorder point** | **19 plants** | Alert when inventory drops below this |
-
-Automate reorder notifications via email or webhook when inventory drops below the reorder point. Track supplier lead times over time and adjust reorder points accordingly to account for seasonal variations or supply chain changes.
-
-## Accuracy and auditing
-
-Maintain inventory accuracy through regular physical counts and comprehensive audit trails. Use cycle counting—counting a different section each week rather than everything at once. High-value or fast-moving items should be counted weekly, while slow-movers can be quarterly.
-
-Log all inventory changes with timestamps, reasons, and the user who made the change. This creates an audit trail for troubleshooting discrepancies and preventing fraud.
-
-| Change type | Reason code | Approval required |
-|-------------|-------------|-------------------|
-| Stock received | `shipment_received` | No |
-| Order shipped | `order_fulfilled` | No |
-| Damaged goods | `shrinkage_damaged` | Manager approval |
-| Manual adjustment | `count_correction` | Manager approval |
-
-
-Plants are trickier than most inventory due to perishability, growth, and quality variance. Regular physical counts catch issues before they impact customers.
-
-
-## Multi-location inventory
-
-For operations with multiple greenhouses, warehouses, or stores, choose a strategy that balances complexity with delivery speed.
-
-| Strategy | Best for | Trade-offs |
-|----------|----------|------------|
-| **Centralized** | Small operations, specialty items | Simpler to manage, slower/costlier shipping |
-| **Distributed** | Large operations, fast delivery needs | Faster delivery, more complex management |
-| **Hybrid** | Most operations | Popular items everywhere, specialty items central | Balanced approach |
-
-Route orders to the optimal location based on proximity to customer, current stock availability, and shipping costs. Allow transfers between locations for balancing inventory across facilities.
diff --git a/fern/docs/pages/capabilities/order-processing.mdx b/fern/docs/pages/capabilities/order-processing.mdx
deleted file mode 100644
index 80c40c8..0000000
--- a/fern/docs/pages/capabilities/order-processing.mdx
+++ /dev/null
@@ -1,86 +0,0 @@
----
-title: Order processing
-subtitle: Manage orders from creation through delivery with automated status tracking
-slug: order-processing
----
-
-## Overview
-
-The Plant Store API manages the complete order lifecycle, from purchase through delivery. Use it to create orders, process payments, track fulfillment, and handle cancellations and refunds.
-
-
-
- Step-by-step guide to creating and processing an order.
-
-
- Explore order endpoints and schemas.
-
-
-
-## Order status
-
-Orders progress through these states:
-
-```mermaid
-stateDiagram-v2
- [*] --> pending
- pending --> paid: Payment confirmed
- pending --> cancelled: Payment failed
-
- paid --> processing: Begin fulfillment
- paid --> cancelled: Customer cancels
-
- processing --> shipped: Carrier pickup
- processing --> cancelled: Issue found
-
- shipped --> delivered: Customer receives
-
- cancelled --> refunded: Process refund
- refunded --> [*]
- delivered --> [*]
-```
-
-| Status | Description | Typical duration |
-|--------|-------------|------------------|
-| `pending` | Order created, awaiting payment | Minutes to hours |
-| `paid` | Payment confirmed, ready for fulfillment | Hours to days |
-| `processing` | Being prepared for shipment | 1-2 business days |
-| `shipped` | In transit to customer | 2-7 business days |
-| `delivered` | Successfully received | Final state |
-| `cancelled` | Order cancelled before shipment | Leads to refund |
-| `refunded` | Payment returned to customer | Final state |
-
-
-Only allow order modifications before the `processing` status. Once fulfillment starts, cancel and create a new order instead.
-
-
-## Payment and inventory coordination
-
-Effective order processing requires careful synchronization between payment and inventory systems. Reserve inventory immediately when an order is created to prevent overselling. If payment fails or times out, release the reservation automatically. Only deduct from physical stock when the order actually ships.
-
-For payments, authorize at checkout to verify funds exist, but capture (actually charge) only after validating inventory and preparing to ship. This two-step approach reduces chargebacks from unfulfilled orders and provides better fraud prevention.
-
-
-Separate authorization and capture gives you time to validate inventory before actually charging the customer. Most payment processors support a 7-day window between authorization and capture.
-
-
-## Customer notifications
-
-Keep customers informed at every stage with automated notifications. Send a confirmation email immediately after order creation, notify when payment is received, and provide tracking information when the order ships. Following up after delivery with care instructions helps ensure satisfaction and reduces support queries.
-
-| Event | Notification | Content to include |
-|-------|-------------|-------------------|
-| Order created | Confirmation email | Order details, items, estimated delivery |
-| Payment received | Payment confirmation | Amount charged, next steps |
-| Order shipped | Shipping notification | Tracking number, carrier, estimated arrival |
-| Order delivered | Delivery confirmation | Care instructions, review request |
-
-Update order status in real-time and log all changes with timestamps to create an audit trail. Make the current status visible to customers at all times through their account dashboard or order tracking pages.
diff --git a/fern/docs/pages/capabilities/plant-management.mdx b/fern/docs/pages/capabilities/plant-management.mdx
deleted file mode 100644
index 6acdf88..0000000
--- a/fern/docs/pages/capabilities/plant-management.mdx
+++ /dev/null
@@ -1,69 +0,0 @@
----
-title: Plant management
-subtitle: Organize and maintain your plant catalog with flexible categorization and search
-slug: plant-management
----
-
-## Overview
-
-The Plant Store API's plant management capabilities let you create, organize, and maintain your plant catalog with rich metadata and flexible categorization. Use it to create and update plant listings, organize by categories and tags, control availability status, and search and filter for customers and internal operations.
-
-
-
- Learn how to search and filter your plant catalog.
-
-
- Explore plant management endpoints and schemas.
-
-
-
-## Plant status values
-
-Plants in your catalog have availability states that reflect inventory. Status should automatically sync with inventory levels to prevent overselling.
-
-| Status | When to use |
-|--------|-------------|
-| `available` | In stock and ready to purchase |
-| `pending` | Reserved for orders or incoming shipments |
-| `sold` | No longer available for new orders |
-
-
-Always update plant status when inventory changes. Stale status values lead to overselling and customer disappointment.
-
-
-## Categorization strategies
-
-Organize plants to help customers find what they need. Most successful plant stores use multiple categorization methods simultaneously.
-
-| Strategy | Categories | Example use case |
-|----------|-----------|------------------|
-| **Care difficulty** | Easy, Moderate, Advanced | Help beginners find low-maintenance plants |
-| **Environment** | Indoor, Outdoor, Tropical, Desert | Match plants to customer's space |
-| **Size** | Small, Medium, Large | Filter by available space constraints |
-
-Use categories for broad grouping (mutually exclusive choices like Indoor vs Outdoor), and tags for flexible overlapping labels like "pet-friendly", "air-purifying", or "low-light". This dual approach gives customers maximum flexibility when browsing.
-
-
-Include scientific names alongside common names. Many experienced plant enthusiasts search by scientific names, and it helps differentiate between similar common names.
-
-
-## Handling variants
-
-Different pot sizes or colors of the same plant should be tracked separately for pricing and inventory purposes. Create separate plant records for each variant and link them using consistent tags or naming conventions. For example, "Snake Plant - 4 inch" and "Snake Plant - 6 inch" as distinct SKUs.
-
-| Approach | Pros | Cons |
-|----------|------|------|
-| Separate products | Independent pricing and inventory | More records to manage |
-| Single product with variants | Cleaner catalog | Complex inventory tracking |
-
-
-Most plant stores find separate products simpler to implement and more flexible for pricing adjustments.
-
diff --git a/fern/docs/pages/concepts.mdx b/fern/docs/pages/concepts.mdx
deleted file mode 100644
index e1fcaf8..0000000
--- a/fern/docs/pages/concepts.mdx
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: Key Concepts
-subtitle: Resources that will help you get started using the Plant Store API
-slug: concepts
-description: Learn about the Plant, Store, and User resources that comprise the Plant Store API.
----
-
-### Plant
-
-A plant can be bought from the store. It has a name, a category, a status, and a list of photo URLs.
-
-### Store
-
-A store has a collection of plants. It is responsible for managing the inventory of plants. Users place orders for plants from the store.
-
-### User
-
-A user is a person who buys plants from the store. Also known as plant parents.
-
-
-
- Learn when and how much to water different types of plants. Overwatering is one of the most common mistakes!
-
-
- Understand the difference between full sun, partial shade, and low light conditions.
-
-
- Discover the right soil types and feeding schedules for healthy plant growth.
-
-
- Identify and treat common pests, diseases, and plant health issues.
-
-
\ No newline at end of file
diff --git a/fern/docs/pages/customization.mdx b/fern/docs/pages/customization.mdx
new file mode 100644
index 0000000..71360a8
--- /dev/null
+++ b/fern/docs/pages/customization.mdx
@@ -0,0 +1,73 @@
+---
+title: Customize your docs
+subtitle: Brand your documentation with colors, logos, and layouts
+slug: customization
+---
+
+The `docs.yml` file controls the visual appearance of your documentation site. Explore the customization options below and click through to the Fern documentation for detailed configuration guides.
+
+
+
+ Set brand colors for light and dark modes
+
+
+ Add your logo and favicon
+
+
+ Customize fonts for headings and body text
+
+
+ Configure page width, tabs placement, and more
+
+
+ Add links and buttons to your navigation bar
+
+
+ Advanced styling with custom CSS and JavaScript
+
+
+
+## Quick example
+
+Here's a minimal example showing common customization options in `docs.yml`:
+
+```yaml title="docs.yml"
+title: Your Documentation
+
+colors:
+ accentPrimary:
+ dark: "#81C784"
+ light: "#1B5E20"
+
+logo:
+ dark: docs/assets/logo-dark.svg
+ light: docs/assets/logo-light.svg
+
+favicon: docs/assets/favicon.svg
+```
+
+For complete configuration options, see the [site-level settings documentation](https://buildwithfern.com/learn/docs/configuration/site-level-settings).
diff --git a/fern/docs/pages/editing-your-docs.mdx b/fern/docs/pages/editing-your-docs.mdx
new file mode 100644
index 0000000..e0f650d
--- /dev/null
+++ b/fern/docs/pages/editing-your-docs.mdx
@@ -0,0 +1,107 @@
+---
+title: Edit your docs
+subtitle: Preview changes locally and publish updates using the CLI or Fern Editor
+slug: editing-your-docs
+---
+
+Fern provides two ways to edit your documentation: the command-line interface (CLI) for developers, and Fern Editor for team members who prefer a visual interface.
+
+
+
+
+The Fern CLI lets you preview changes locally and publish updates from your terminal.
+
+
+
+
+```bash
+npm install -g fern-api
+```
+
+
+
+
+
+Start a local development server with hot-reloading:
+
+```bash
+fern docs dev
+```
+
+This serves your documentation at [http://localhost:3000](http://localhost:3000).
+
+
+
+
+
+Create a shareable preview URL for your team to review changes before publishing:
+
+```bash
+fern generate --docs --preview
+```
+
+
+
+
+
+When you're ready for your docs to be publicly accessible:
+
+```bash
+fern generate --docs
+```
+
+This builds and publishes your documentation to the URL configured in `docs.yml`.
+
+
+
+
+For detailed CLI documentation, see the [Fern CLI reference](https://buildwithfern.com/learn/cli-api-reference/cli-reference/overview).
+
+
+
+
+
+Fern Editor is a visual editor that lets anyone on your team update documentation without learning Markdown or Git. It's ideal for content writers, product managers, and other non-technical contributors.
+
+**Key features**
+
+Fern Editor provides rich text editing similar to Notion or Google Docs, support for Fern components like Callouts and Cards, and a GitHub-backed workflow that creates pull requests for review.
+
+**Get started**
+
+1. Log in to the [Fern Dashboard](https://dashboard.buildwithfern.com/)
+2. Connect your GitHub repository
+3. Open Fern Editor from the top navigation
+
+Changes made in Fern Editor create pull requests automatically, maintaining your docs-as-code workflow with full Git history and review process.
+
+For more details on Fern Editor features and supported components, see the [Fern Editor documentation](https://buildwithfern.com/learn/docs/writing-content/fern-editor).
+
+
+
+
+## Next steps
+
+
+
+ Create pages using MDX and components
+
+
+ Configure tabs, sections, and pages
+
+
+ Brand your documentation
+
+
diff --git a/fern/docs/pages/get-started/overview.mdx b/fern/docs/pages/get-started/overview.mdx
deleted file mode 100644
index 1f15f19..0000000
--- a/fern/docs/pages/get-started/overview.mdx
+++ /dev/null
@@ -1,129 +0,0 @@
----
-title: Overview
-subtitle: Welcome to the Plant Store API
-slug: overview
----
-
-The Plant Store API is a complete e-commerce platform designed for plant retailers. It handles everything from catalog management and inventory tracking to order processing and customer relationships.
-
-## What you can build
-
-The Plant Store API provides the building blocks for plant retail operations:
-
-
-
- Build online storefronts with real-time inventory, shopping carts, and checkout flows.
-
-
- Create native iOS and Android apps for browsing plants and placing orders.
-
-
- Track stock across multiple locations with automated reorder alerts.
-
-
- Manage your catalog, process orders, and analyze customer behavior.
-
-
-
-## Core capabilities
-
-The API is organized around four main capabilities, each handling a specific aspect of plant retail:
-
-
-
- Create and organize your plant catalog with rich metadata, images, and categorization. Control availability status as inventory changes and enable customers to search and filter by care level, environment, or tags.
-
-
- Handle the complete order lifecycle from purchase through delivery. Process payments, track fulfillment status, and manage cancellations and refunds. Every order automatically reserves inventory to prevent overselling.
-
-
- Build lasting relationships with detailed customer profiles, order history, and communication preferences. Support multiple shipping addresses, track purchase patterns, and segment customers for targeted marketing.
-
-
- Maintain accurate stock levels across all sales channels with real-time updates. Set automated reorder alerts, reserve inventory for pending orders, and track changes with comprehensive audit trails.
-
-
-
-## How it works
-
-When a customer browses your catalog, the plant management system handles search and filtering. Creating an order triggers the order processing system, which validates payment. On successful payment, inventory tracking reserves stock and manages fulfillment. Throughout the process, customer management sends notifications and maintains order history. If payment fails, the system cancels the order and notifies the customer automatically.
-
-
-```mermaid
-graph TD
- A[Customer browses plants] --> B[Plant Management]
- B --> C[Adds to cart]
- C --> D[Creates order]
-
- D --> E[Order Processing]
- E --> F{Payment successful?}
-
- F -->|Yes| G[Inventory Tracking]
- F -->|No| H[Cancel & notify]
-
- G --> I[Reserve stock]
- I --> J[Fulfill order]
- J --> K[Update inventory]
-
- K --> L[Customer Management]
- L --> M[Send notifications]
- L --> N[Update order history]
-
- H --> L
-```
-
-
-## Rate limits
-
-The Plant Store API has the following rate limits to ensure reliable service:
-
-| Plan | Requests per minute | Burst limit |
-|------|-------------------|-------------|
-| Free | 60 | 100 |
-| Pro | 600 | 1000 |
-| Enterprise | Custom | Custom |
-
-If you exceed your rate limit, you'll receive a `429 Too Many Requests` response. Implement exponential backoff to handle rate limit errors gracefully.
-
-## SDKs and libraries
-
-Official SDKs are available for popular languages. Each SDK handles authentication, error handling, and request formatting automatically, making integration faster and more reliable than using the raw REST API.
-
-
-
- ```bash
- pip install plantstore-sdk
- ```
-
-
- ```bash
- npm install @plantstore/sdk
- ```
-
-
- ```bash
- go get github.com/plantstore/plantstore-go
- ```
-
-
-
-## Getting help
-
-
-
- Make your first API request in minutes
-
-
- Complete endpoint documentation
-
-
- Step-by-step integration guides
-
-
- Contact our team for help
-
-
-
----
-
-
diff --git a/fern/docs/pages/get-started/quickstart.mdx b/fern/docs/pages/get-started/quickstart.mdx
deleted file mode 100644
index 2a96140..0000000
--- a/fern/docs/pages/get-started/quickstart.mdx
+++ /dev/null
@@ -1,182 +0,0 @@
----
-title: Quickstart
-subtitle: Get up and running with the Plant Store API in minutes
-slug: quickstart
----
-
-This guide shows you how to make your first API request to the Plant Store API using our SDKs.
-
-## Making your first API request
-
-
-
-
-[Create an API key in your dashboard](https://plantstore.com/settings/api-keys), which you'll use to authenticate your requests.
-
-Store the key securely and pass it to the SDK either as an environment variable via a `.env` file, or directly in your app's configuration.
-
-```bash title=".env"
-PLANT_STORE_API_KEY=your_api_key_here
-```
-
-
-Never commit API keys to version control. Use environment variables and rotate keys regularly for security.
-
-
-
-
-
-
-Install the Plant Store SDK for your preferred language:
-
-
-```bash Python
-pip install plantstore-sdk
-pip install python-dotenv
-```
-
-```bash TypeScript
-npm install @plantstore/sdk
-npm install dotenv
-```
-
-```bash Go
-go get github.com/plantstore/plantstore-go
-```
-
-
-
-
-
-
-Create a new file and add the following code to search for available plants:
-
-
-```python Python
-# quickstart.py
-import os
-from dotenv import load_dotenv
-from plantstore import PlantStoreClient
-
-load_dotenv()
-
-client = PlantStoreClient(
- api_key=os.getenv("PLANT_STORE_API_KEY")
-)
-
-# Search for available plants
-plants = client.plants.search(status="available")
-
-print(f"Found {len(plants)} available plants:")
-for plant in plants[:5]:
- print(f"- {plant.name} (${plant.price})")
-```
-
-```typescript TypeScript
-// quickstart.ts
-import { PlantStoreClient } from '@plantstore/sdk';
-import 'dotenv/config';
-
-const client = new PlantStoreClient({
- apiKey: process.env.PLANT_STORE_API_KEY
-});
-
-async function searchPlants() {
- // Search for available plants
- const plants = await client.plants.search({
- status: 'available'
- });
-
- console.log(`Found ${plants.length} available plants:`);
- plants.slice(0, 5).forEach(plant => {
- console.log(`- ${plant.name} ($${plant.price})`);
- });
-}
-
-searchPlants();
-```
-
-```go Go
-// main.go
-package main
-
-import (
- "fmt"
- "log"
- "os"
-
- "github.com/joho/godotenv"
- "github.com/plantstore/plantstore-go"
-)
-
-func main() {
- godotenv.Load()
-
- client := plantstore.NewClient(
- plantstore.WithAPIKey(os.Getenv("PLANT_STORE_API_KEY")),
- )
-
- // Search for available plants
- plants, err := client.Plants.Search(&plantstore.PlantSearchRequest{
- Status: "available",
- })
- if err != nil {
- log.Fatal(err)
- }
-
- fmt.Printf("Found %d available plants:\n", len(plants))
- for i := 0; i < 5 && i < len(plants); i++ {
- fmt.Printf("- %s ($%.2f)\n", plants[i].Name, plants[i].Price)
- }
-}
-```
-
-
-
-
-
-
-
-```bash Python
-python quickstart.py
-```
-
-```bash TypeScript
-npx tsx quickstart.ts
-```
-
-```bash Go
-go run main.go
-```
-
-
-You should see a list of available plants from your catalog.
-
-
-
-
-## Next steps
-
-
-
- Learn how to search and filter your plant catalog
-
-
- Build a complete order workflow
-
-
- Explore all available endpoints
-
-
diff --git a/fern/docs/pages/light.mdx b/fern/docs/pages/light.mdx
deleted file mode 100644
index d4e7a2b..0000000
--- a/fern/docs/pages/light.mdx
+++ /dev/null
@@ -1,118 +0,0 @@
----
-title: Light requirements
-subtitle: Understanding plant lighting needs
-slug: light
-description: Learn about different light levels and how to provide the right amount of light for your plants to thrive.
----
-
-Light is essential for photosynthesis and healthy plant growth. Understanding your home's light conditions and matching them to the right plants is key to success.
-
-## Light levels explained
-
-### Full sun (direct light)
-- **6+ hours** of direct sunlight per day
-- Usually south-facing windows
-- Hot, bright spots
-- Best for: Succulents, cacti, herbs, vegetables, flowering plants
-
-### Bright indirect light
-- **4-6 hours** of bright but filtered light
-- Near east or west-facing windows
-- Light is bright but not hitting plants directly
-- Best for: Most tropical plants, ferns, many houseplants
-
-### Medium light (partial shade)
-- **2-4 hours** of indirect light
-- Several feet from a bright window
-- North-facing windows
-- Best for: Pothos, philodendrons, snake plants
-
-### Low light (shade)
-- **Less than 2 hours** of indirect light
-- Corners of rooms, hallways
-- Far from windows
-- Best for: Snake plants, ZZ plants, cast iron plants
-
-## How to assess your light
-
-### The shadow test
-Hold your hand 12 inches above where you want to place your plant:
-- **Sharp, defined shadow**: Bright/direct light
-- **Soft, fuzzy shadow**: Medium light
-- **Barely visible shadow**: Low light
-
-### Watch the sun
-Observe your space throughout the day:
-- **Morning sun** (east): Gentle, great for most plants
-- **Afternoon sun** (west): Intense, can be too hot
-- **All-day sun** (south): Brightest, best for sun-lovers
-- **No direct sun** (north): Lowest light
-
-## Signs of light problems
-
-### Too much light
-- Bleached or faded leaves
-- Brown, crispy patches (sunburn)
-- Leaves turning yellow
-- Wilting despite adequate water
-- Soil drying very quickly
-
-### Too little light
-- Leggy, stretched growth
-- Leaning toward light source
-- Small, pale new leaves
-- Slow or no growth
-- Lower leaves dropping
-- Variegated plants losing patterns
-
-## Solutions for light issues
-
-### Increasing light
-- Move closer to windows
-- Use mirrors to reflect light
-- Clean windows and leaves (dust blocks light)
-- Paint walls white or light colors
-- **Use grow lights** for low-light spaces
-
-### Reducing light
-- Move away from windows
-- Use sheer curtains to filter light
-- Place plants behind taller plants
-- Relocate to north-facing windows
-
-## Grow lights
-
-When natural light isn't enough, supplement with artificial lighting:
-
-### Types of grow lights
-- **LED**: Energy-efficient, cool, full spectrum
-- **Fluorescent**: Good for seedlings and herbs
-- **Full spectrum bulbs**: Mimic natural sunlight
-
-### Grow light tips
-- Place 6-12 inches above plants
-- Run for 12-16 hours per day
-- Use timers for consistency
-- Adjust height as plants grow
-
-## Seasonal changes
-
-### Summer
-- Longer days mean more light
-- Watch for sun damage as sun angle changes
-- May need to move plants away from windows
-
-### Winter
-- Shorter days mean less light
-- Consider moving plants closer to windows
-- Supplement with grow lights if needed
-- Rotate plants more frequently
-
-## Pro tips
-
-- **Rotate plants weekly** for even growth on all sides
-- **Acclimate gradually** when moving to brighter spots
-- **Clean leaves monthly** to maximize light absorption
-- **South-facing windows** get the most light in Northern Hemisphere
-- **Observe your plants** - they'll tell you what they need
-- **Use the right window** - not all windows are equal
\ No newline at end of file
diff --git a/fern/docs/pages/navigation.mdx b/fern/docs/pages/navigation.mdx
new file mode 100644
index 0000000..3ee203c
--- /dev/null
+++ b/fern/docs/pages/navigation.mdx
@@ -0,0 +1,69 @@
+---
+title: Set up navigation
+subtitle: Configure tabs, sections, and pages in your docs.yml file
+slug: navigation
+---
+
+The `docs.yml` file controls the navigation structure of your documentation site. Explore the navigation options below and click through to the Fern documentation for detailed configuration guides.
+
+
+
+ Organize content into sections with pages and folders
+
+
+ Create top-level navigation groups
+
+
+ Add version switching for your documentation
+
+
+ Support multiple products in one site
+
+
+ Auto-generate API documentation from your spec
+
+
+ Add a changelog section to your docs
+
+
+
+## Quick example
+
+Here's a minimal example showing navigation structure in `docs.yml`:
+
+```yaml title="docs.yml"
+navigation:
+ - section: Getting started
+ contents:
+ - page: Introduction
+ path: docs/pages/intro.mdx
+ - page: Quickstart
+ path: docs/pages/quickstart.mdx
+ - api: API Reference
+```
+
+For complete navigation options, see the [navigation documentation](https://buildwithfern.com/learn/docs/configuration/navigation).
diff --git a/fern/docs/pages/sdks.mdx b/fern/docs/pages/sdks.mdx
deleted file mode 100644
index d122ce2..0000000
--- a/fern/docs/pages/sdks.mdx
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: SDKs
-subtitle: We offer client libraries for your favorite languages, generated by Fern from your OpenAPI specification file.
-slug: sdks
----
-
-We provide official open-source SDKs (client libraries) for your favorite languages, such as Node.js and Python. These clients make connecting to our API faster and help avoid errors.
-
-We regularly update our SDKs using [Fern](https://buildwithfern.com/?utm_campaign=demo&utm_medium=plantstore&utm_source=markdown_sdks) and adhere to [semantic versioning](https://semver.org/) (semver) principles, so we won't make breaking changes in minor or patch releases.
-
-## Official SDKs
-
-
-
-```shell Node
-bash npm install plantstore-sdk # or yarn add plantstore-sdk
-```
-
-```shell Python
-bash pip install plantstore
-```
-
-```shell Go
-bash go get -u github.com/fern-demo/plantstore-go
-```
-
-```xml Java (Maven)
-
- com.buildwithfern.plantstore
- plantstore
- 0.0.1
-
-```
-
-```gradle Java (Gradle)
-implementation 'com.buildwithfern.plantstore:plantstore:0.0.1'
-```
-
-```shell Ruby
-bash gem install plantstore
-```
-
-```shell C#
-bash nuget install plantstore.net
-```
-
-
-
-## Request a new SDK
-
-If you'd like to request an SDK for a language that we don't currently support, [let us know](/welcome#get-support). We're always looking to expand our SDK offerings and would love to hear from you.
diff --git a/fern/docs/pages/support.mdx b/fern/docs/pages/support.mdx
new file mode 100644
index 0000000..f351c8e
--- /dev/null
+++ b/fern/docs/pages/support.mdx
@@ -0,0 +1,21 @@
+---
+title: Support
+subtitle: Get help from the Fern team and community
+slug: support
+---
+
+Have questions about Fern or need help with your documentation? Start here.
+
+## Contact Fern
+
+For product questions, migrations, or enterprise support, reach out to the Fern team:
+
+- Join the [Fern Slack community](https://buildwithfern.com/slack) for quick questions and feedback
+- Use the [contact form](https://buildwithfern.com/contact) for sales, enterprise, or migration inquiries
+
+### GitHub and issues
+
+If you run into bugs or want to request features, open an issue on GitHub:
+
+- [docs-starter repository](https://github.com/fern-api/docs-starter/issues) – issues specific to this starter template
+- [Fern repository](https://github.com/fern-api/fern/issues) – general Fern platform bugs and feature requests
diff --git a/fern/docs/pages/tutorials/first-order-tutorial.mdx b/fern/docs/pages/tutorials/first-order-tutorial.mdx
deleted file mode 100644
index ff76320..0000000
--- a/fern/docs/pages/tutorials/first-order-tutorial.mdx
+++ /dev/null
@@ -1,298 +0,0 @@
----
-title: Creating your first order
-subtitle: Learn how to create and process an order end-to-end
-slug: first-order-tutorial
----
-
-This guide shows you how to create a complete order workflow, from customer creation through order fulfillment.
-
-## Creating and processing an order
-
-
-
-
-[Create an API key in your dashboard](https://plantstore.com/settings/api-keys), which you'll use to authenticate your requests.
-
-Store the key securely and pass it to the SDK either as an environment variable via a `.env` file, or directly in your app's configuration.
-
-```bash title=".env"
-PLANT_STORE_API_KEY=your_api_key_here
-```
-
-
-
-
-
-We'll also use the `dotenv` library to load our API key from an environment variable.
-
-
-```bash Python
-pip install plantstore-sdk
-pip install python-dotenv
-```
-
-```bash TypeScript
-npm install @plantstore/sdk
-npm install dotenv
-```
-
-```bash Go
-go get github.com/plantstore/plantstore-go
-```
-
-
-
-
-
-
-Create a new file named `create_order.py`, `create_order.ts`, or `main.go` and add the following code:
-
-
-```python Python
-# create_order.py
-import os
-from dotenv import load_dotenv
-from plantstore import PlantStoreClient
-
-load_dotenv()
-
-client = PlantStoreClient(
- api_key=os.getenv("PLANT_STORE_API_KEY")
-)
-
-# Create a customer
-customer = client.customers.create(
- email="gardener@example.com",
- name="Jane Smith",
- phone="+1-555-0123"
-)
-
-print(f"Created customer: {customer.id}")
-
-# Browse available plants
-plants = client.plants.search(status="available")
-selected_plant = plants[0]
-
-print(f"Selected plant: {selected_plant.name}")
-
-# Create the order
-order = client.orders.create(
- customer_id=customer.id,
- items=[
- {
- "plant_id": selected_plant.id,
- "quantity": 2,
- "price": selected_plant.price
- }
- ],
- shipping_address={
- "street": "123 Garden Ave",
- "city": "Portland",
- "state": "OR",
- "zip": "97201"
- }
-)
-
-print(f"Created order: {order.id}")
-
-# Process payment
-payment = client.orders.process_payment(
- order_id=order.id,
- payment_method="card",
- amount=order.total
-)
-
-print(f"Payment processed: {payment.status}")
-
-# Update order status to processing
-updated_order = client.orders.update(
- order_id=order.id,
- status="processing"
-)
-
-print(f"Order status: {updated_order.status}")
-print(f"Order complete! ID: {order.id}")
-```
-
-```typescript TypeScript
-// create_order.ts
-import { PlantStoreClient } from '@plantstore/sdk';
-import 'dotenv/config';
-
-const client = new PlantStoreClient({
- apiKey: process.env.PLANT_STORE_API_KEY
-});
-
-async function createOrder() {
- // Create a customer
- const customer = await client.customers.create({
- email: 'gardener@example.com',
- name: 'Jane Smith',
- phone: '+1-555-0123'
- });
-
- console.log(`Created customer: ${customer.id}`);
-
- // Browse available plants
- const plants = await client.plants.search({ status: 'available' });
- const selectedPlant = plants[0];
-
- console.log(`Selected plant: ${selectedPlant.name}`);
-
- // Create the order
- const order = await client.orders.create({
- customerId: customer.id,
- items: [
- {
- plantId: selectedPlant.id,
- quantity: 2,
- price: selectedPlant.price
- }
- ],
- shippingAddress: {
- street: '123 Garden Ave',
- city: 'Portland',
- state: 'OR',
- zip: '97201'
- }
- });
-
- console.log(`Created order: ${order.id}`);
-
- // Process payment
- const payment = await client.orders.processPayment({
- orderId: order.id,
- paymentMethod: 'card',
- amount: order.total
- });
-
- console.log(`Payment processed: ${payment.status}`);
-
- // Update order status to processing
- const updatedOrder = await client.orders.update({
- orderId: order.id,
- status: 'processing'
- });
-
- console.log(`Order status: ${updatedOrder.status}`);
- console.log(`Order complete! ID: ${order.id}`);
-}
-
-createOrder();
-```
-
-```go Go
-// main.go
-package main
-
-import (
- "fmt"
- "log"
- "os"
-
- "github.com/joho/godotenv"
- "github.com/plantstore/plantstore-go"
-)
-
-func main() {
- godotenv.Load()
-
- client := plantstore.NewClient(
- plantstore.WithAPIKey(os.Getenv("PLANT_STORE_API_KEY")),
- )
-
- // Create a customer
- customer, err := client.Customers.Create(&plantstore.CustomerCreateRequest{
- Email: "gardener@example.com",
- Name: "Jane Smith",
- Phone: "+1-555-0123",
- })
- if err != nil {
- log.Fatal(err)
- }
-
- fmt.Printf("Created customer: %s\n", customer.ID)
-
- // Browse available plants
- plants, err := client.Plants.Search(&plantstore.PlantSearchRequest{
- Status: "available",
- })
- if err != nil {
- log.Fatal(err)
- }
- selectedPlant := plants[0]
-
- fmt.Printf("Selected plant: %s\n", selectedPlant.Name)
-
- // Create the order
- order, err := client.Orders.Create(&plantstore.OrderCreateRequest{
- CustomerID: customer.ID,
- Items: []plantstore.OrderItem{
- {
- PlantID: selectedPlant.ID,
- Quantity: 2,
- Price: selectedPlant.Price,
- },
- },
- ShippingAddress: plantstore.Address{
- Street: "123 Garden Ave",
- City: "Portland",
- State: "OR",
- Zip: "97201",
- },
- })
- if err != nil {
- log.Fatal(err)
- }
-
- fmt.Printf("Created order: %s\n", order.ID)
-
- // Process payment
- payment, err := client.Orders.ProcessPayment(&plantstore.PaymentRequest{
- OrderID: order.ID,
- PaymentMethod: "card",
- Amount: order.Total,
- })
- if err != nil {
- log.Fatal(err)
- }
-
- fmt.Printf("Payment processed: %s\n", payment.Status)
-
- // Update order status
- updatedOrder, err := client.Orders.Update(&plantstore.OrderUpdateRequest{
- OrderID: order.ID,
- Status: "processing",
- })
- if err != nil {
- log.Fatal(err)
- }
-
- fmt.Printf("Order status: %s\n", updatedOrder.Status)
- fmt.Printf("Order complete! ID: %s\n", order.ID)
-}
-```
-
-
-
-
-
-
-
-```bash Python
-python create_order.py
-```
-
-```bash TypeScript
-npx tsx create_order.ts
-```
-
-```bash Go
-go run main.go
-```
-
-
-You should see output showing each step of the order creation process, ending with the completed order ID.
-
-
-
\ No newline at end of file
diff --git a/fern/docs/pages/tutorials/inventory-tutorial.mdx b/fern/docs/pages/tutorials/inventory-tutorial.mdx
deleted file mode 100644
index 6e8651a..0000000
--- a/fern/docs/pages/tutorials/inventory-tutorial.mdx
+++ /dev/null
@@ -1,428 +0,0 @@
----
-title: Managing plant inventory
-subtitle: Learn how to track and manage your plant stock levels
-slug: inventory-tutorial
----
-
-This guide shows you how to manage your plant inventory, from adding new stock to setting up automated reorder alerts.
-
-## Building an inventory management system
-
-
-
-
-[Create an API key in your dashboard](https://plantstore.com/settings/api-keys) to authenticate your requests.
-
-```bash title=".env"
-PLANT_STORE_API_KEY=your_api_key_here
-```
-
-
-
-
-
-
-```bash Python
-pip install plantstore-sdk
-pip install python-dotenv
-```
-
-```bash TypeScript
-npm install @plantstore/sdk
-npm install dotenv
-```
-
-```bash Go
-go get github.com/plantstore/plantstore-go
-```
-
-
-
-
-
-
-Create a new file named `manage_inventory.py`, `manage_inventory.ts`, or `main.go` with the following code:
-
-
-```python Python
-# manage_inventory.py
-import os
-from dotenv import load_dotenv
-from plantstore import PlantStoreClient
-
-load_dotenv()
-
-client = PlantStoreClient(api_key=os.getenv("PLANT_STORE_API_KEY"))
-
-# Add a new plant with initial stock
-plant = client.plants.create(
- name="Snake Plant",
- category="Indoor",
- tags=["low-light", "beginner-friendly", "air-purifying"],
- status="available",
- stock=25,
- price=29.99,
- location="greenhouse_a"
-)
-
-print(f"Added plant: {plant.name} (ID: {plant.id})")
-print(f"Initial stock: {plant.stock}")
-```
-
-```typescript TypeScript
-// manage_inventory.ts
-import { PlantStoreClient } from '@plantstore/sdk';
-import 'dotenv/config';
-
-const client = new PlantStoreClient({
- apiKey: process.env.PLANT_STORE_API_KEY
-});
-
-async function addPlant() {
- // Add a new plant with initial stock
- const plant = await client.plants.create({
- name: 'Snake Plant',
- category: 'Indoor',
- tags: ['low-light', 'beginner-friendly', 'air-purifying'],
- status: 'available',
- stock: 25,
- price: 29.99,
- location: 'greenhouse_a'
- });
-
- console.log(`Added plant: ${plant.name} (ID: ${plant.id})`);
- console.log(`Initial stock: ${plant.stock}`);
-}
-
-addPlant();
-```
-
-```go Go
-// main.go
-package main
-
-import (
- "fmt"
- "log"
- "os"
-
- "github.com/joho/godotenv"
- "github.com/plantstore/plantstore-go"
-)
-
-func main() {
- godotenv.Load()
-
- client := plantstore.NewClient(
- plantstore.WithAPIKey(os.Getenv("PLANT_STORE_API_KEY")),
- )
-
- // Add a new plant with initial stock
- plant, err := client.Plants.Create(&plantstore.PlantCreateRequest{
- Name: "Snake Plant",
- Category: "Indoor",
- Tags: []string{"low-light", "beginner-friendly", "air-purifying"},
- Status: "available",
- Stock: 25,
- Price: 29.99,
- Location: "greenhouse_a",
- })
- if err != nil {
- log.Fatal(err)
- }
-
- fmt.Printf("Added plant: %s (ID: %s)\n", plant.Name, plant.ID)
- fmt.Printf("Initial stock: %d\n", plant.Stock)
-}
-```
-
-
-
-
-
-
-Add code to check the current inventory status:
-
-
-```python Python
-# Check inventory for the plant
-inventory = client.inventory.get(plant_id=plant.id)
-
-print(f"\nInventory Status:")
-print(f"On-hand: {inventory.quantity}")
-print(f"Reserved: {inventory.reserved}")
-print(f"Available: {inventory.available}")
-print(f"Location: {inventory.location}")
-```
-
-```typescript TypeScript
-// Check inventory for the plant
-const inventory = await client.inventory.get({
- plantId: plant.id
-});
-
-console.log('\nInventory Status:');
-console.log(`On-hand: ${inventory.quantity}`);
-console.log(`Reserved: ${inventory.reserved}`);
-console.log(`Available: ${inventory.available}`);
-console.log(`Location: ${inventory.location}`);
-```
-
-```go Go
-// Check inventory for the plant
-inventory, err := client.Inventory.Get(&plantstore.InventoryGetRequest{
- PlantID: plant.ID,
-})
-if err != nil {
- log.Fatal(err)
-}
-
-fmt.Println("\nInventory Status:")
-fmt.Printf("On-hand: %d\n", inventory.Quantity)
-fmt.Printf("Reserved: %d\n", inventory.Reserved)
-fmt.Printf("Available: %d\n", inventory.Available)
-fmt.Printf("Location: %s\n", inventory.Location)
-```
-
-
-
-
-
-
-Add functionality to update inventory when you receive shipments:
-
-
-```python Python
-# Receive new shipment
-updated_inventory = client.inventory.update(
- plant_id=plant.id,
- quantity=40,
- note="Received shipment from supplier"
-)
-
-print(f"\nStock updated to: {updated_inventory.quantity}")
-```
-
-```typescript TypeScript
-// Receive new shipment
-const updatedInventory = await client.inventory.update({
- plantId: plant.id,
- quantity: 40,
- note: 'Received shipment from supplier'
-});
-
-console.log(`\nStock updated to: ${updatedInventory.quantity}`);
-```
-
-```go Go
-// Receive new shipment
-updatedInventory, err := client.Inventory.Update(&plantstore.InventoryUpdateRequest{
- PlantID: plant.ID,
- Quantity: 40,
- Note: "Received shipment from supplier",
-})
-if err != nil {
- log.Fatal(err)
-}
-
-fmt.Printf("\nStock updated to: %d\n", updatedInventory.Quantity)
-```
-
-
-
-
-
-
-Configure automatic alerts when inventory runs low:
-
-
-```python Python
-# Configure low-stock alert
-alert = client.inventory.set_alert(
- plant_id=plant.id,
- reorder_point=10,
- notify_email="inventory@plantstore.com"
-)
-
-print(f"\nLow-stock alert set: {alert.reorder_point} units")
-```
-
-```typescript TypeScript
-// Configure low-stock alert
-const alert = await client.inventory.setAlert({
- plantId: plant.id,
- reorderPoint: 10,
- notifyEmail: 'inventory@plantstore.com'
-});
-
-console.log(`\nLow-stock alert set: ${alert.reorderPoint} units`);
-```
-
-```go Go
-// Configure low-stock alert
-alert, err := client.Inventory.SetAlert(&plantstore.InventoryAlertRequest{
- PlantID: plant.ID,
- ReorderPoint: 10,
- NotifyEmail: "inventory@plantstore.com",
-})
-if err != nil {
- log.Fatal(err)
-}
-
-fmt.Printf("\nLow-stock alert set: %d units\n", alert.ReorderPoint)
-```
-
-
-
-
-
-
-Demonstrate how to reserve stock when processing orders:
-
-
-```python Python
-# Reserve stock for an order
-reservation = client.inventory.reserve(
- plant_id=plant.id,
- quantity=2,
- order_id="order_123",
- expires_at="2025-11-01T10:00:00Z"
-)
-
-print(f"\nReserved {reservation.quantity} units for order {reservation.order_id}")
-
-# Check updated inventory
-updated = client.inventory.get(plant_id=plant.id)
-print(f"Reserved: {updated.reserved}, Available: {updated.available}")
-```
-
-```typescript TypeScript
-// Reserve stock for an order
-const reservation = await client.inventory.reserve({
- plantId: plant.id,
- quantity: 2,
- orderId: 'order_123',
- expiresAt: '2025-11-01T10:00:00Z'
-});
-
-console.log(`\nReserved ${reservation.quantity} units for order ${reservation.orderId}`);
-
-// Check updated inventory
-const updated = await client.inventory.get({ plantId: plant.id });
-console.log(`Reserved: ${updated.reserved}, Available: ${updated.available}`);
-```
-
-```go Go
-// Reserve stock for an order
-reservation, err := client.Inventory.Reserve(&plantstore.InventoryReserveRequest{
- PlantID: plant.ID,
- Quantity: 2,
- OrderID: "order_123",
- ExpiresAt: "2025-11-01T10:00:00Z",
-})
-if err != nil {
- log.Fatal(err)
-}
-
-fmt.Printf("\nReserved %d units for order %s\n", reservation.Quantity, reservation.OrderID)
-
-// Check updated inventory
-updated, err := client.Inventory.Get(&plantstore.InventoryGetRequest{
- PlantID: plant.ID,
-})
-if err != nil {
- log.Fatal(err)
-}
-fmt.Printf("Reserved: %d, Available: %d\n", updated.Reserved, updated.Available)
-```
-
-
-
-
-
-
-
-```bash Python
-python manage_inventory.py
-```
-
-```bash TypeScript
-npx tsx manage_inventory.ts
-```
-
-```bash Go
-go run main.go
-```
-
-
-You should see output showing:
-- Plant creation with initial stock
-- Current inventory status
-- Stock updates from shipments
-- Alert configuration
-- Stock reservation for orders
-
-
-
-
-
-
-### Batch inventory updates
-
-For processing large shipments, use batch updates:
-
-
-```python Python
-# Update multiple plants at once
-batch_result = client.inventory.batch_update(
- updates=[
- {"plant_id": "plant_123", "quantity": 30},
- {"plant_id": "plant_456", "quantity": 15},
- {"plant_id": "plant_789", "quantity": 22}
- ]
-)
-print(f"Updated {len(batch_result.updated)} plants")
-```
-
-```typescript TypeScript
-// Update multiple plants at once
-const batchResult = await client.inventory.batchUpdate({
- updates: [
- { plantId: 'plant_123', quantity: 30 },
- { plantId: 'plant_456', quantity: 15 },
- { plantId: 'plant_789', quantity: 22 }
- ]
-});
-console.log(`Updated ${batchResult.updated.length} plants`);
-```
-
-
-### Inventory history tracking
-
-View all changes to understand inventory patterns:
-
-
-```python Python
-# Get inventory history
-history = client.inventory.get_history(
- plant_id=plant.id,
- limit=10
-)
-
-for event in history:
- print(f"{event.timestamp}: {event.change:+d} units - {event.reason}")
-```
-
-```typescript TypeScript
-// Get inventory history
-const history = await client.inventory.getHistory({
- plantId: plant.id,
- limit: 10
-});
-
-history.forEach(event => {
- console.log(`${event.timestamp}: ${event.change:+d} units - ${event.reason}`);
-});
-```
-
-
diff --git a/fern/docs/pages/tutorials/searching-plants.mdx b/fern/docs/pages/tutorials/searching-plants.mdx
deleted file mode 100644
index 3416ff4..0000000
--- a/fern/docs/pages/tutorials/searching-plants.mdx
+++ /dev/null
@@ -1,215 +0,0 @@
----
-title: Searching for plants
-subtitle: Learn how to search and filter your plant catalog
-slug: searching-plants
----
-
-This guide shows you how to search for plants in your catalog using filters and tags to find exactly what you need.
-
-## Using the Plant Search API
-
-
-
-
-[Create an API key in your dashboard](https://plantstore.com/settings/api-keys), which you'll use to authenticate your requests.
-
-Store the key securely and pass it to the SDK either as an environment variable via a `.env` file, or directly in your app's configuration.
-
-```bash title=".env"
-PLANT_STORE_API_KEY=your_api_key_here
-```
-
-
-
-
-
-
-```bash Python
-pip install plantstore-sdk
-pip install python-dotenv
-```
-
-```bash TypeScript
-npm install @plantstore/sdk
-npm install dotenv
-```
-
-```bash Go
-go get github.com/plantstore/plantstore-go
-```
-
-
-
-
-
-
-Create a new file named `search_plants.py`, `search_plants.ts`, or `main.go` and add the following code:
-
-
-```python Python
-# search_plants.py
-import os
-from dotenv import load_dotenv
-from plantstore import PlantStoreClient
-
-load_dotenv()
-
-client = PlantStoreClient(
- api_key=os.getenv("PLANT_STORE_API_KEY")
-)
-
-# Search for available plants
-plants = client.plants.search(status="available")
-
-print(f"Found {len(plants)} available plants:")
-for plant in plants[:5]:
- print(f"- {plant.name} (${plant.price})")
-
-# Search by tags
-beginner_plants = client.plants.search(
- tags=["beginner-friendly", "low-light"]
-)
-
-print(f"\nBeginner-friendly plants:")
-for plant in beginner_plants[:3]:
- print(f"- {plant.name}: {', '.join(plant.tags)}")
-
-# Get a specific plant by ID
-plant = client.plants.get(plant_id=plants[0].id)
-print(f"\nPlant details:")
-print(f"Name: {plant.name}")
-print(f"Status: {plant.status}")
-print(f"Tags: {', '.join(plant.tags)}")
-```
-
-```typescript TypeScript
-// search_plants.ts
-import { PlantStoreClient } from '@plantstore/sdk';
-import 'dotenv/config';
-
-const client = new PlantStoreClient({
- apiKey: process.env.PLANT_STORE_API_KEY
-});
-
-async function searchPlants() {
- // Search for available plants
- const plants = await client.plants.search({
- status: 'available'
- });
-
- console.log(`Found ${plants.length} available plants:`);
- plants.slice(0, 5).forEach(plant => {
- console.log(`- ${plant.name} ($${plant.price})`);
- });
-
- // Search by tags
- const beginnerPlants = await client.plants.search({
- tags: ['beginner-friendly', 'low-light']
- });
-
- console.log('\nBeginner-friendly plants:');
- beginnerPlants.slice(0, 3).forEach(plant => {
- console.log(`- ${plant.name}: ${plant.tags.join(', ')}`);
- });
-
- // Get a specific plant by ID
- const plant = await client.plants.get({
- plantId: plants[0].id
- });
-
- console.log('\nPlant details:');
- console.log(`Name: ${plant.name}`);
- console.log(`Status: ${plant.status}`);
- console.log(`Tags: ${plant.tags.join(', ')}`);
-}
-
-searchPlants();
-```
-
-```go Go
-// main.go
-package main
-
-import (
- "fmt"
- "log"
- "os"
- "strings"
-
- "github.com/joho/godotenv"
- "github.com/plantstore/plantstore-go"
-)
-
-func main() {
- godotenv.Load()
-
- client := plantstore.NewClient(
- plantstore.WithAPIKey(os.Getenv("PLANT_STORE_API_KEY")),
- )
-
- // Search for available plants
- plants, err := client.Plants.Search(&plantstore.PlantSearchRequest{
- Status: "available",
- })
- if err != nil {
- log.Fatal(err)
- }
-
- fmt.Printf("Found %d available plants:\n", len(plants))
- for i := 0; i < 5 && i < len(plants); i++ {
- fmt.Printf("- %s ($%.2f)\n", plants[i].Name, plants[i].Price)
- }
-
- // Search by tags
- beginnerPlants, err := client.Plants.Search(&plantstore.PlantSearchRequest{
- Tags: []string{"beginner-friendly", "low-light"},
- })
- if err != nil {
- log.Fatal(err)
- }
-
- fmt.Println("\nBeginner-friendly plants:")
- for i := 0; i < 3 && i < len(beginnerPlants); i++ {
- fmt.Printf("- %s: %s\n",
- beginnerPlants[i].Name,
- strings.Join(beginnerPlants[i].Tags, ", "))
- }
-
- // Get a specific plant by ID
- plant, err := client.Plants.Get(&plantstore.PlantGetRequest{
- PlantID: plants[0].ID,
- })
- if err != nil {
- log.Fatal(err)
- }
-
- fmt.Println("\nPlant details:")
- fmt.Printf("Name: %s\n", plant.Name)
- fmt.Printf("Status: %s\n", plant.Status)
- fmt.Printf("Tags: %s\n", strings.Join(plant.Tags, ", "))
-}
-```
-
-
-
-
-
-
-
-```bash Python
-python search_plants.py
-```
-
-```bash TypeScript
-npx tsx search_plants.ts
-```
-
-```bash Go
-go run main.go
-```
-
-
-You should see a list of available plants, beginner-friendly options, and detailed information about a specific plant.
-
-
-
diff --git a/fern/docs/pages/welcome.mdx b/fern/docs/pages/welcome.mdx
index acc8d7b..dcc713b 100644
--- a/fern/docs/pages/welcome.mdx
+++ b/fern/docs/pages/welcome.mdx
@@ -1,74 +1,120 @@
---
-title: Welcome to Plant Store API
-subtitle: Everything you need to build plant retail experiences
+title: Welcome to Fern!
+subtitle: Everything you need to build the best developer experience
slug: welcome
---
-The Plant Store API provides a complete platform for building plant retail applications. From catalog management and inventory tracking to order processing and customer relationships, our API handles the complexity so you can focus on creating great experiences.
+This repository is a starter template for building documentation with [Fern](https://buildwithfern.com). It includes a sample Plant Store API to demonstrate how Fern generates interactive API reference documentation from an OpenAPI specification.
-## Quick links
+Use this template to get started quickly, then replace the sample content with your own API and documentation.
+
+## What's included
+
+This starter template contains everything you need to publish documentation:
+
+
+
+
+
+
+
+
+
+
+
+## Getting started
+
+
+
+
+```bash
+git clone
+cd docs-starter
+```
+
+
+
+
+
+```bash
+npm install -g fern-api
+```
+
+
+
+
+
+Start a local development server with hot-reloading:
+
+```bash
+fern docs dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) to see your docs.
+
+
+
+
+
+Update `fern.config.json` with your organization name and `docs.yml` with your desired URL:
+
+```json title="fern.config.json"
+{
+ "organization": "your-org-name",
+ "version": "0.46.15"
+}
+```
+
+```yaml title="docs.yml"
+instances:
+ - url: your-org.docs.buildwithfern.com
+```
+
+
+
+
+
+When you're ready to go live:
+
+```bash
+fern generate --docs
+```
+
+
+
+
+## Next steps
+
+Replace the sample Plant Store API with your own OpenAPI specification, update the Markdown pages with your content, and customize the theme to match your brand. For detailed guidance, explore the pages in this documentation or visit the [Fern documentation](https://buildwithfern.com/learn).
- Understand what you can build with the Plant Store API
+ Learn how to preview and publish changes using the CLI or Fern Editor
- Make your first API request in minutes
+ Configure tabs, sections, and pages in your docs.yml file
- Step-by-step guides for common workflows
+ Brand your documentation with colors, logos, and layouts
- Complete endpoint documentation and schemas
+ See how Fern generates interactive API documentation
-## Core capabilities
-
-Build complete plant retail operations with these integrated capabilities:
-
-| Capability | What you can do |
-|------------|-----------------|
-| **Plant management** | Organize your catalog with categories, tags, and rich metadata |
-| **Order processing** | Handle the complete lifecycle from cart to delivery |
-| **Customer management** | Build relationships with profiles, preferences, and history |
-| **Inventory tracking** | Maintain accurate stock with real-time updates and alerts |
-
-
-New to the Plant Store API? Start with the [Overview](/overview) to understand the platform, then follow the [Quickstart](/quickstart) to make your first API call.
-
-
-## What you can build
-
-- **E-commerce websites** - Online storefronts with real-time inventory and checkout
-- **Mobile applications** - Native iOS and Android shopping experiences
-- **Inventory systems** - Multi-location stock tracking and management
-- **Admin dashboards** - Internal tools for catalog and order management
-
-## Get support
-
-Have questions or need help? We're here for you:
-
-- **Documentation issues** - [Open an issue on GitHub](https://github.com/fern-api/docs-starter-openapi/issues)
-- **General support** - [Email our team](mailto:support+plantstore@buildwithfern.com)
-- **Community** - [Join our Slack](https://join.slack.com/t/fern-community/shared_invite/zt-2q7ev4mki-mhO5anKslwRowp4oExWf4A)
-
----
-
-
\ No newline at end of file
diff --git a/fern/docs/pages/writing-content.mdx b/fern/docs/pages/writing-content.mdx
new file mode 100644
index 0000000..ef00aef
--- /dev/null
+++ b/fern/docs/pages/writing-content.mdx
@@ -0,0 +1,58 @@
+---
+title: Write content
+subtitle: Create documentation pages using MDX
+slug: writing-content
+---
+
+Documentation pages are written in MDX, which combines Markdown with React components. Create `.mdx` files in the `docs/pages/` directory and reference them in your `docs.yml` navigation.
+
+## Basic page structure
+
+```markdown title="docs/pages/my-page.mdx"
+---
+title: Page title
+subtitle: Optional subtitle
+slug: my-page
+---
+
+Your content here. Use standard Markdown formatting like **bold**, *italic*, and `code`.
+
+## Headings
+
+Use headings to organize your content.
+```
+
+## Using components
+
+Fern provides [built-in components](https://buildwithfern.com/learn/docs/writing-content/components/overview) for common documentation patterns:
+
+
+
+Highlight important information with callouts.
+
+
+
+
+ Card description
+
+
+ Another description
+
+
+
+
+```jsx Markdown
+
+Highlight important information with callouts.
+
+
+
+
+ Card description
+
+
+ Another description
+
+
+```
+
diff --git a/fern/snippets/note.mdx b/fern/snippets/note.mdx
index 555425d..acc19ec 100644
--- a/fern/snippets/note.mdx
+++ b/fern/snippets/note.mdx
@@ -1,3 +1,3 @@
-This is a demonstration of documentation built with [Fern](https://buildwithfern.com). You can [use this template](https://github.com/fern-api/docs-starter-openapi) as a starting point for your own API documentation.
-
\ No newline at end of file
+This documentation is built with [Fern](https://buildwithfern.com). For detailed guidance on customizing your docs, visit the [Fern documentation](https://buildwithfern.com/learn).
+