llms-full.txt

# GraphQL-Markdown Documentation

> Human-friendly documentation for GraphQL-Markdown schemas and tooling.

Complete offline export of the core docs, API reference, and worked examples published on graphql-markdown.dev.

## Introduction


The `@graphql-markdown/cli` package adds a CLI with commands for generating MDX using a GraphQL schema as the source. It simplifies creating and maintaining GraphQL API documentation by automatically generating well-structured documentation from your schema.

## Why GraphQL Markdown?

Managing API documentation can be time-consuming and prone to becoming outdated. This package solves these challenges by:

- Automatically generating documentation from your schema
- Keeping documentation in sync with your API
- Providing a consistent documentation structure
- Integrating seamlessly with most of the MDX documentation frameworks

## Features

- Easy set up and customizable output
- Full cross-linking between types with visual relationship hierarchy
- MDX output fully customizable using your own components
- Extensible lifecycle hooks and events system
- Any schema loader compatible with `@graphql-tools/load` — SDL files, remote endpoints, or code-first TS/JS schemas
- Group types into categories using directives
- Namespaced operations (nested query/mutation/subscription objects)
- GraphQL config support

## Quick Install

For **Docusaurus** projects:

```bash
npm install @graphql-markdown/docusaurus graphql
```

For **other MDX frameworks** (Astro, Next.js, etc.):

```bash
npm install @graphql-markdown/cli graphql
```

---

## Getting started


:::info

While GraphQL-Markdown was initially developed as a Docusaurus plugin, it now supports various MDX documentation generators. This guide focuses on the Docusaurus integration - for other frameworks, please see our [Framework Integration Guide](/docs/advanced/integration-with-frameworks).

:::

Get started by [creating a new site](#new-docusaurus-site).

Or try GraphQL-Markdown immediately with our [demo](/docs/try-it).

## New Docusaurus site

### Requirements

Node.js version [20.0](https://nodejs.org/en/download/) or above (which can be checked by running `node -v`) is required.

:::info[Package managers]

You can use either `npm`, `yarn`, or `pnpm` as your package manager. The examples in this documentation use `npm`, but you can substitute the commands with your preferred package manager.

When installing Node.js, you are recommended to check all checkboxes related to dependencies.

:::

:::tip

You can use [nvm](https://github.com/nvm-sh/nvm), installed on a single machine, to manage multiple Node.js versions.

:::

### Generate a new site

Generate a new Docusaurus site using the [GraphQL-Markdown template](https://github.com/graphql-markdown/template).

The template will automatically be added to your project after you run the command:

```shell title="shell"
npm init docusaurus my-website https://github.com/graphql-markdown/template.git
```

You can type this command into Command Prompt, Powershell, Terminal, or any other integrated terminal of your code editor.

The command also installs all the necessary dependencies you need to run Docusaurus.

### Add a GraphQL schema loader

A schema loader is required to load your GraphQL schema. The template comes with `@graphql-tools/url-loader` pre-configured for remote schemas.

See [schema loading](/docs/advanced/schema-loading) for other loaders and configuration options.

### Start your site

Run the development server:

```shell title="shell"
cd my-website
npm start
```

:::tip

The `npm run doc` command is a shortcut in the template for command-line document generation: `npm run docusaurus graphql-to-doc`.

:::

The `npm run start` command builds your website locally and serves it through a development server, ready for you to view at [http://localhost:3000/](http://localhost:3000/).

## Existing Docusaurus site

### Prerequisites

:::note

These requirements are specific to Docusaurus integration. See our [Framework Integration Guide](/docs/advanced/integration-with-frameworks) for other frameworks' requirements.

:::

Your project needs to meet the following requirements:

- Node.js version [20.0](https://nodejs.org/en/download/) or above
- [Docusaurus](https://docusaurus.io/) instance version 2.0 or above with the [docs plugin](https://docusaurus.io/docs/docs-introduction) enabled
- [GraphQL.js](https://graphql.org/graphql-js/) version 16.0 or above

### Install the plugin

Add the `@graphql-markdown/docusaurus` plugin to your site installation:

```shell title="shell"
npm install @graphql-markdown/docusaurus graphql
```

### Add a schema loader

See [schema loading](/docs/advanced/schema-loading).

### Configure the plugin

See [configuration](/docs/configuration).

## Update your documentation

Build your website:

```shell title="shell"
npm run docusaurus build
```

Or run the documentation generator directly:

```shell title="shell"
npm run docusaurus graphql-to-doc
```

The `npm run docusaurus graphql-to-doc` command generates MDX files locally from your GraphQL schema. The possible command flags are documented in [settings](/docs/settings).

---

## Try it


## Docusaurus

Use the [CodeSandbox template](https://codesandbox.io/p/sandbox/github/graphql-markdown/demo-docusaurus/tree/main?file=/.graphqlrc) or fork our [demo repo](https://github.com/graphql-markdown/demo-docusaurus) to try with your own GraphQL schema.

Edit the configuration in `.graphqlrc`.

## Astro/Starlight

Use the [CodeSandbox template](https://codesandbox.io/p/sandbox/github/graphql-markdown/demo-astro-starlight/tree/main?file=/.graphqlrc) or fork our [demo repo](https://github.com/graphql-markdown/demo-astro-starlight) to try with your own GraphQL schema.

Edit the configuration in `graphql.config.mjs`.

## Next.js/Fumadocs

Use the [CodeSandbox template](https://codesandbox.io/p/sandbox/github/graphql-markdown/demo-nextjs-fumadocs/tree/main?file=/.graphqlrc) or fork our [demo repo](https://github.com/graphql-markdown/demo-nextjs-fumadocs) to try with your own GraphQL schema.

Edit the configuration in `graphql.config.mjs`.

## Vite/Vocs

Fork our [demo repo](https://github.com/graphql-markdown/demo-vite-vocs) to try with your own GraphQL schema.

Edit the configuration in `graphql.config.mjs`.

## HonKit / GitBook legacy

Fork our [demo repo](https://github.com/graphql-markdown/demo-honkit) to try with your own GraphQL schema.

Edit the configuration in `graphql.config.mjs`.

---

## How It Works


GraphQL-Markdown reads your schema, parses every type and operation, and writes one MDX file per type category — ready to publish with Docusaurus or any MDX framework.

## Pipeline

![pipeline](/img/docs/pipeline.png)

### Input

Given this schema:

```graphql
type User {
  """User's unique identifier"""
  id: ID!
  """User's full name"""
  name: String!
  """List of posts authored by this user"""
  posts: [Post!]
}

type Post {
  id: ID!
  title: String!
  author: User!
}

type Query {
  getUser(id: ID!): User
  getPosts: [Post!]!
}
```

### Output

GraphQL-Markdown generates a file per type category. For example, `objects/user.mdx`:

```mdx
---
id: user
title: User
---

# User

Object Type

## Fields

| Name | Type | Description |
| ---- | ---- | ----------- |
| `id` | `ID!` | User's unique identifier |
| `name` | `String!` | User's full name |
| `posts` | [`[Post!]`](/docs/graphql/objects/post) | List of posts authored by this user |

## Returned by

[`getUser`](/docs/graphql/queries/get-user)
```

Notice the cross-link on `Post` and the back-reference under "Returned by" — these are generated automatically from the schema graph.

## What gets generated

| Output | Description |
| ------ | ----------- |
| `objects/` | One file per Object type |
| `inputs/` | One file per Input type |
| `queries/` | One file per Query field |
| `mutations/` | One file per Mutation field |
| `subscriptions/` | One file per Subscription field |
| `enums/` | One file per Enum type |
| `interfaces/` | One file per Interface type |
| `unions/` | One file per Union type |
| `scalars/` | One file per Scalar type |
| `_category_.yml` | Sidebar metadata for each folder |

## Customization

The generation pipeline exposes lifecycle hooks at every stage — before/after schema load, before/after rendering each type, before/after composing each page. See [hook recipes](/docs/advanced/hook-recipes) and [custom directives](/docs/advanced/custom-directive).

To see the full output in action, browse the [live examples](/examples/default).

---

## Configuration Cheat Sheet


:::note
This is a quick reference guide. All settings are thoroughly documented in the [**Settings** page](/docs/settings).
:::

## Essential Options

| Option     | Type     | Default    | Description                                               |
| ---------- | -------- | ---------- | --------------------------------------------------------- |
| `schema`   | `string` | —          | **Required**. Path to schema file or introspection result |
| `rootPath` | `string` | `./docs`   | Root folder for documentation generation                  |
| `baseURL`  | `string` | `/graphql` | Base URL path for generated documentation                 |

## Document Structure

| Option         | Type                     | Default | Description                                                           |
| -------------- | ------------------------ | ------- | --------------------------------------------------------------------- |
| `linkRoot`     | `string`                 | `/`     | Root path used for type cross-links in generated documentation        |
| `homepage`     | `string`                 | —       | Custom homepage content file                                          |
| `hierarchy`    | `string`                 | `api`   | Documentation structure: `api`, `entity`, or `flat`                   |
| `index`        | `boolean`                | `false` | Generate category indices                                             |
| `categorySort` | `string` \| `function`   | —       | Sort categories: `"natural"` for alphabetical or custom function      |
| `pretty`       | `boolean`                | `false` | Format generated Markdown files                                       |

## Content Options

| Option          | Type      | Default | Description                |
| --------------- | --------- | ------- | -------------------------- |
| `noCode`        | `boolean` | `false` | Hide code sections         |
| `noExample`     | `boolean` | `false` | Hide example sections      |
| `noParentType`  | `boolean` | `false` | Hide parent type prefix    |
| `noRelatedType` | `boolean` | `false` | Hide related types section |
| `noTypeBadges`  | `boolean` | `false` | Hide type badges           |

## Filtering Options

| Option             | Type       | Default   | Description                                                        |
| ------------------ | ---------- | --------- | ------------------------------------------------------------------ |
| `groupByDirective` | `string`   | —         | Group by directive: `@directive(field)` or `@directive(=fallback)` |
| `only`             | `string[]` | —         | Include only types with specified directives                       |
| `skip`             | `string[]` | —         | Exclude types with specified directives                            |
| `deprecated`       | `string`   | `default` | Handling of deprecated items: `default`, `group`, `skip`           |

## Build Control Options

| Option        | Type      | Default | Description                                                       |
| ------------- | --------- | ------- | ----------------------------------------------------------------- |
| `force`       | `boolean` | `false` | Force regeneration of all files                                   |
| `diffMethod`  | `string`  | `NONE`  | Change detection: `NONE`, `FORCE`, `SCHEMA-DIFF`, `SCHEMA-HASH`   |
| `tmpDir`      | `string`  | —       | Temporary directory for storing schema signature (used by diff)   |
| `pretty`      | `boolean` | `false` | Format output files with Prettier (requires `prettier` installed) |
| `mdxParser`   | `string`  | —       | Path to a custom MDX formatter module                             |

## CLI Flags

All config options can be passed as CLI flags to `npx docusaurus graphql-to-doc` or `npx graphql-markdown`.

| Flag                              | Config option                         | Description                                    |
| --------------------------------- | ------------------------------------- | ---------------------------------------------- |
| `-s, --schema <path>`             | `schema`                              | Schema file, URL, or introspection JSON        |
| `-b, --base <baseURL>`            | `baseURL`                             | Base URL and output folder name                |
| `-r, --root <rootPath>`           | `rootPath`                            | Root output folder                             |
| `-l, --link <linkRoot>`           | `linkRoot`                            | Root path for cross-links                      |
| `-h, --homepage <file>`           | `homepage`                            | Custom homepage file                           |
| `-f, --force`                     | `force`                               | Skip diff, always regenerate                   |
| `-d, --diff <method>`             | `diffMethod`                          | Diff method (`NONE`, `SCHEMA-DIFF`, etc.)      |
| `-t, --tmp <dir>`                 | `tmpDir`                              | Temp dir for schema diffing                    |
| `--index`                         | `docOptions.index`                    | Generate category index pages                  |
| `--hierarchy <type>`              | `printTypeOptions.hierarchy`          | Folder structure: `api`, `entity`, `flat`      |
| `--deprecated <option>`           | `printTypeOptions.deprecated`         | `default`, `group`, or `skip`                  |
| `--noParentType`                  | `printTypeOptions.parentTypePrefix`   | Hide parent type prefix on fields              |
| `--noTypeBadges`                  | `printTypeOptions.typeBadges`         | Hide type attribute badges                     |
| `--only <@directive...>`          | `onlyDocDirective`                    | Include only types with these directives       |
| `--skip <@directive...>`          | `skipDocDirective`                    | Exclude types with these directives            |
| `-gdb, --groupByDirective <expr>` | `groupByDirective`                    | Group by directive: `@dir(field\|=fallback)`   |
| `--pretty`                        | `pretty`                              | Format output with Prettier                    |
| `--mdxParser <path>`              | `mdxParser`                           | Custom MDX formatter module                    |
| `--config`                        | —                                     | Print resolved config (debug)                  |

---

## Configuration


GraphQL-Markdown supports three configuration methods. Later entries in this list take precedence over earlier ones.

## Framework-agnostic Configuration

### GraphQL Config

:::tip
GraphQL Config is the recommended way to configure GraphQL-Markdown across all frameworks.
:::

You can use a [GraphQL Config](https://the-guild.dev/graphql/config/docs/user/usage) file (multiple formats supported) to configure GraphQL-Markdown:

```yaml title=".graphqlrc"
schema: "https://graphql.anilist.co/"
extensions:
  graphql-markdown:
    linkRoot: "/examples/default"
    baseURL: "."
    homepage: "data/anilist.md"
    loaders:
      UrlLoader:
        module: "@graphql-tools/url-loader"
        options:
          method: "POST"
    printTypeOptions:
      deprecated: "group"
```

## Docusaurus Integration

### Plugin Configuration

You can define plugin settings directly in your Docusaurus configuration file `docusaurus.config.js`:

```js title="docusaurus.config.js"
module.exports = {
  // ...
  plugins: [
    [
      "@graphql-markdown/docusaurus",
      /** @type {import('@graphql-markdown/types').ConfigOptions} */
      {
        schema: "./schema/swapi.graphql",
        rootPath: "./docs", // docs will be generated under './docs/swapi' (rootPath/baseURL)
        baseURL: "swapi",
        homepage: "./docs/swapi.md",
        loaders: {
          GraphQLFileLoader: "@graphql-tools/graphql-file-loader", // local file schema
        },
        // Optional advanced settings
        pretty: true,
      },
    ],
  ],
};
```

All settings are described in the page **[settings](/docs/settings)**.

:::tip

If you want to use several GraphQL schemas, read our guide for **[additional schemas](/docs/advanced/additional-schema)**.

:::

### Site Settings

You will also need to add a link to your documentation on your site. One way to do it is to add it to your site's `navbar` in `docusaurus.config.js`:

```js title="docusaurus.config.js"
module.exports = {
  // ...
  navbar: {
    items: [
      {
        to: "/swapi/homepage", // adjust the location depending on your baseURL (see configuration)
        label: "SWAPI Schema", // change the label with yours
        position: "left",
      },
    ],
  },
};
```

For more details about the `navbar`, please refer to Docusaurus [documentation](https://docusaurus.io/docs/api/themes/configuration#navbar).

## Configuration Lifecycle

GraphQL-Markdown processes configuration sources in the following priority order (later sources override earlier ones):

1. **Default configuration**: Built-in default settings
2. **GraphQL Config file** (`.graphqlrc`): Framework-agnostic project settings
3. **Framework-specific configuration**: (e.g., Docusaurus plugin settings)
4. **CLI flags**: Command-line arguments override all other settings

:::tip
For any framework, you can use CLI flags to temporarily override settings without modifying your configuration files.
:::

**Current limitations:**
- Single schema only, no schema stitching
- `include`, `exclude`, `documents` and glob pattern are not supported

---

## Additional schemas


If you need to support multiple schemas, then you can set multiple instances of the plugin

Assign a unique `id` attribute to each plugin instance (if not set, then `id` value is `default`).

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // highlight-next-line
      // id: 'default', // omitted => default instance
      schema: "./schema/swapi.graphql",
      rootPath: "./docs", // docs will be generated under './docs/swapi' (rootPath/baseURL)
      baseURL: "swapi",
      homepage: "./docs/swapi.md",
      loaders: {
        GraphQLFileLoader: "@graphql-tools/graphql-file-loader" // local file schema
      }
    },
  ],
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // highlight-next-line
      id: "admin",
      schema: "./schema/admin.graphql",
      rootPath: "./docs", // docs will be generated under './docs/admin' (rootPath/baseURL)
      baseURL: "admin",
      homepage: "./docs/admin.md",
      loaders: {
        GraphQLFileLoader: "@graphql-tools/graphql-file-loader" // local file schema
      }
    },
  ],
],
```

Instance with an `id` will have their command line:

```shell
npm run docusaurus graphql-to-doc:admin
```

## GraphQL Config

If you use [GraphQL config](/docs/configuration#graphql-config), then you need to define `projects` with the same `id` (including `default`).

```js title="docusaurus.config.js"
plugins: [
  "@graphql-markdown/docusaurus", // default instance
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // highlight-next-line
      id: "admin",
    },
  ],
],
```

```yaml title=".graphqlrc"
projects:
  # highlight-next-line
  default:
    schema: "./schema/swapi.graphql"
    extensions:
      graphql-markdown:
        linkRoot: "./docs"
        baseURL: "swapi"
        homepage: "./docs/swapi.md"
        loaders:
          GraphQLFileLoader: "@graphql-tools/graphql-file-loader"
  # highlight-next-line
  admin:
    schema: "./schema/admin.graphql"
    extensions:
      graphql-markdown:
        linkRoot: "./docs"
        baseURL: "admin"
        homepage: "./docs/admin.md"
        loaders:
          GraphQLFileLoader: "@graphql-tools/graphql-file-loader"
```

---

## Customize deprecated sections


When using the option [`printTypeOptions.deprecated`](/docs/settings#printtypeoptions) set to `group`, the rendering can be customized using the CSS class `.deprecated`.

Adding a `warning` emoji ⚠️ is done with a quick tweak of [Docusaurus CSS](https://docusaurus.io/docs/styling-layout).

```css title="/src/css/custom.css"
.deprecated a::after,
span.deprecated::after {
  content: "⚠️";
  padding-left: 4px !important;
  transform: none !important;
}

.deprecated {
  padding-top: 1rem;
}
```

The above CSS will render the deprecated sections as the following

![custom-deprecated-section](/img/docs/custom-deprecated-section.png)

---

## Custom schema directives handling


For directives applied to the schema, you can select which ones to be rendered for the types or in the locations they are declared. Information about the custom directives includes a custom description.

For example, we have one query called `searchRole`, and we want to limit access to `ADMIN` user roles only.

We can accomplish this by adding a directive called `auth` with an argument `requires` to the query.

```graphql
directive @auth(requires: Roles = ADMIN) on OBJECT | FIELD_DEFINITION

enum Roles {
  ADMIN
  USER
}

type Query {
  searchRole(roles: [Roles!]! = [ADMIN]): Int! @auth
}
```

## Usage

Add the option [`customDirective`](/docs/settings#customdirective) to the `@graphql-markdown/docusaurus` configuration.

The `descriptor` and `tag` functions receive 2 arguments:

- `directive` of type [`GraphQLDirective`](https://github.com/graphql/graphql-js/blob/main/src/type/directives.ts)
- `node` of type [`GraphQLNamedType`](https://github.com/graphql/graphql-js/blob/main/src/type/definition.ts) or [`ASTNode`](https://github.com/graphql/graphql-js/blob/main/src/language/ast.ts)

```ts
type DirectiveName = string & { _opaque: typeof DirectiveName };

type CustomDirective = {
  [name: DirectiveName]: {
    descriptor?: (directive?: GraphQLDirective, node?: unknown): string;
    tag?: (directive?: GraphQLDirective, node?: unknown): Badge;
  };
};

type Badge = {
  text: string | TypeLocale;
  classname: string;
};
```

### `descriptor`

The `descriptor` allows rendering the custom directive's description applicable to entities.

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // ... other options
      customDirective: {
        auth: {
          // highlight-start
          descriptor: (directive, node) =>
            directiveDescriptor(
              directive,
              node,
              "This requires the current user to be in `${requires}` role.",
            ),
          // highlight-end
        }
        // ... other custom directive options
      },
    },
  ],
],
```

### `tag`

The `tag` allows rendering custom badges (tags) based on the custom directive applicable to entities.

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // ... other options
      customDirective: {
        beta: {
          // highlight-next-line
          tag: (directive, node) => ({ text: directive.name, classname: "badge--info" }),
        }
        // ... other custom directive options
      },
    },
  ],
],
```

### Wildcard

You can use **`"*"` as a wildcard** for the directive name. This will allow all directives not declared with their name under `customDirective` to be handled by the wildcard `descriptor` and/or `tag`.

```js title="docusaurus.config.js"
const { directiveDescriptor, tagDescriptor } = require("@graphql-markdown/helpers");

//...//

plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // ... other options
      customDirective: {
        // highlight-start
        "*": {
          descriptor: directiveDescriptor,
          tag: tagDescriptor,
        },
        // highlight-end
        // ... optionally specific custom directive options
      },
    },
  ],
],
```

## Helpers

The packages `@graphql-markdown/helpers` and `@graphql-markdown/graphql` provide a few helper functions to quickly start.

:::info

`@graphql-markdown/helpers` is an optional peer dependency, and it needs to be installed before using it.

```shell title="shell"
npm i @graphql-markdown/helpers
```

:::

### `@graphql-markdown/helpers`

- [`directiveDescriptor`](/api/helpers/directives/descriptor)
- [`tagDescriptor`](/api/helpers/directives/tag)

### `@graphql-markdown/graphql`

- [`getTypeDirectiveValues`](/api/graphql/introspection#gettypedirectivevalues)
- [`getTypeDirectiveArgValue`](/api/graphql/introspection#gettypedirectiveargvalue)

---

## Custom root types


For custom operation root types (queries not of type `Query`, or root type name used for other purpose), use the loader option `RootTypes`:

```ts
type RootTypes = { query?: string; mutation?: string; subscription?: string };
```

- use a custom type name to override the standard type
- use an empty string to disable the GraphQL standard type
- unset root types will use the GraphQL standard type

Add the option `rootTypes` to the loader options under `@graphql-markdown/docusaurus` configuration (see also [schema loading](/docs/advanced/schema-loading)):

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // ... other options
      loaders: {
        GraphQLFileLoader: {
          module: "@graphql-tools/graphql-file-loader",
          options: {
            // highlight-start
            rootTypes: {
              query: "Root", // use custom root type Root for queries, instead of Query
              subscription: "" // disable Subscription type
            },
            // highlight-end
          },
        },
      },
    },
  ],
],
```

---

## Examples


By enabling the option [`printTypeOptions.exampleSection`](/docs/settings#printtypeoptions), you can add examples to types documentation.

## Usage

**1. Add a type definition directive `@example` to the schema**

  ```graphql
  directive @example(
    value: String
  ) on OBJECT | INPUT_OBJECT | INTERFACE | FIELD_DEFINITION | ARGUMENT_DEFINITION | SCALAR
  ```

**2. Add examples to the schema**

  ```graphql
  scalar Date @example(value: "1970-01-01")

  interface Record {
    id: ID! @example(value: "1")
  }

  type Course implements Record @example(value: "{ \"id\": 2, \"title\": \"GraphQL\" }") {
    id: ID!
    title: String!
  } 

  type Semester implements Record {
    id: ID!
    startDate: Date
    withdrawDate: Date @deprecated
    endDate: Date
    courses: [Course!]!
  }

  type Query {
    course(id: ID!): Course @example(value: "{ course(id: \"1\") { title } }")
  }
  ```

Examples can be inherited, this is why in the above example there is no example explicitly set for the type `Semester`, and it will render as the following

![examples](/img/docs/examples.png)

## Advanced options

Example directive definition and parser behavior can be customized through the configuration using a `TypeDirectiveExample` object instead of a boolean value for `printTypeOptions.exampleSection`:

```ts
interface TypeExampleSectionOption {
  directive?: string; // customize the directive name
  field?: string; // customize the directive's field name
  parser?: (value?: unknown, type?: unknown) => unknown; // customize the field's value parsing
}
```

For example, if the GraphQL schema already supports examples using the `@spectaql` directive.

```graphql
type CustomExampleDirective {
  myField: String @spectaql(options: [{ key: "undocumented", value: "true" }])
  myFieldOtherField: String @spectaql(options: [{ key: "example", value: "An Example from the Directive" }])
  myFieldOtherOtherField: String @spectaql(options: [{ key: "examples", value: "[\"Example 1 from the Directive\", \"Example 2 from the Directive\"]" }])
}
```

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // ... other options
      printTypeOptions: {
        exampleSection: {
          directive: "spectaql",
          field: "options",
          /* simplified parser for @spectaql (non production ready) */
          parser: (options, type) => {
            if (!options) {
              return undefined;
            }

            const example = options.find(
              (option) => {
                return ["example", "examples"].includes(option.key);
              },
            );

            if (!example) {
              return undefined;
            }

            if (example.key === "example") {
              return example.value;
            }

            return JSON.parse(example.value)[0];
          }
        }
      }
    }
  ]
]
```

---

## Documentation categories


You can group the documentation to provide an easier user experience to navigate. This is accomplished by adding a directive to all the types you want to have grouped.

For example, we have two mutations called `addCourse` and `dropCourse`, and we want to group them under a category called `Courses`.

```graphql
type Mutation {
  AddCourse(input: String): String
  DropCourse(input: String): String
}
```

## Usage

We can accomplish this by adding a directive called `doc` with a field `category` to each mutation.

```graphql
type Mutation {
  AddCourse(input: String): String @doc(category: "Course")
  DropCourse(input: String): String @doc(category: "Course")
}
```

We can add a fallback option called `Common` which is for types that we don't explicitly add a directive to.

It can be set either with the command line flag `--groupByDirective`:

```shell
npx docusaurus graphql-to-doc --groupByDirective "@doc(category|=Common)"
```

or the plugin configuration `groupByDirective`:

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // ... other options
      // highlight-start
      groupByDirective: {
        directive: "doc",
        field: "category",
        fallback: "Common", // default is Miscellaneous
      }
      // highlight-end
    },
  ],
],
```

---

## Homepage


If you decide to use a custom homepage for the GraphQL-generated documentation, then set the sidebar position to `sidebar_position: 1` to ensure it shows first:

```markdown title="schema.md"
---
id: schema
slug: /schema
title: Schema Documentation
sidebar_position: 1
---

This documentation has been automatically generated from the GraphQL schema.
```

:::tip

If you want to hide the homepage from the sidebar, then set the front matter `sidebar_class_name` (or `className` depending on your Docusaurus version) to `navbar__toggle`.

```markdown {6} title="schema.md"
---
id: schema
slug: /schema
title: Schema Documentation
sidebar_position: 1
sidebar_class_name: navbar__toggle
---
```

:::

---

## Hooks Recipes


This page lists examples of usage of [hooks](/api/category/events).

:::info

Hooks are part of the [documentation frameworks integration](./integration-with-frameworks.md) API.

:::

## Available Hooks

GraphQL-Markdown provides lifecycle hooks for customizing the documentation generation process.

### Generation Hooks

| Hook                                | Description                                  |
| ----------------------------------- | -------------------------------------------- |
| `beforeSchemaLoadHook`              | Called before loading the GraphQL schema     |
| `afterSchemaLoadHook`               | Called after loading the GraphQL schema      |
| `beforeDiffCheckHook`               | Called before checking schema differences    |
| `afterDiffCheckHook`                | Called after checking schema differences     |
| `beforeRenderRootTypesHook`         | Called before rendering root types           |
| `afterRenderRootTypesHook`          | Called after rendering root types            |
| `beforeRenderHomepageHook`          | Called before rendering the homepage         |
| `afterRenderHomepageHook`           | Called after rendering the homepage          |
| `beforeRenderTypeEntitiesHook`      | Called before rendering type entities        |
| `afterRenderTypeEntitiesHook`       | Called after rendering type entities         |
| `beforeGenerateIndexMetafileHook`   | Called before generating index metafiles     |
| `afterGenerateIndexMetafileHook`    | Called after generating index metafiles      |

### Printer Hooks

| Hook                          | Description                                                                             |
| ----------------------------- | --------------------------------------------------------------------------------------- |
| `beforePrintCodeHook`         | Called before generating code blocks — can modify options or prevent default generation |
| `afterPrintCodeHook`          | Called after generating code blocks — can modify the generated output                   |
| `beforePrintTypeHook`         | Called before generating type documentation — can modify options or prevent default     |
| `afterPrintTypeHook`          | Called after generating type documentation — can modify the generated output            |
| `beforeComposePageTypeHook`   | Called before composing type page sections — can reorder, remove, or inject sections    |

:::info

All hooks receive an `event` object with a `data` property containing context-specific information. Printer hooks also have an `output` property that can be modified.

For `beforeComposePageTypeHook`, `event.output` is the ordered list of section keys to render, and `event.data.sections` is the section content map.

:::

## Using Hooks with Docusaurus

When using Docusaurus, you can extend the default MDX module to add custom hooks while keeping all the built-in formatters:

```js title="custom-mdx.cjs"
const DocusaurusMDX = require("@graphql-markdown/docusaurus/mdx");

const afterPrintCodeHook = async (event) => {
  // Your custom logic here
  event.output = `${event.output}\n\n<!-- Custom content -->`;
};

module.exports = {
  ...DocusaurusMDX,  // Keep all default formatters
  afterPrintCodeHook, // Add your custom hook
};
```

Then configure your Docusaurus plugin to use the custom module:

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    {
      schema: "./schema.graphql",
      // highlight-next-line
      mdxParser: require.resolve("./custom-mdx.cjs"),
      // ... other options
    },
  ],
],
```

## Generate index.md files

You can use this hook to generate `index.md` files.

```md
---
title: "Unions"
---

- [ActivityUnion](./activity-union.mdx)
- [LikeableUnion](./likeable-union.mdx)
- [NotificationUnion](./notification-union.mdx)
```

Declare the custom module in GraphQL-Markdown configuration `mdxParser: "./custom-mdx.mjs"`.

```js title="custom-mdx.mjs"

  ensureDir,
  fileExists,
  saveFile,
  startCase,
} from "@graphql-markdown/utils";

const INDEX_MD = "index.md";

/**
 * Hook that generates an index metadata file for a category directory.
 * 
 * This hook is executed before generating index metadata files. 
 * It checks if an index.md file exists in the specified directory. 
 * If not, it creates one with a title derived from the category name.
 */
const beforeGenerateIndexMetafileHook = async (event) => {
  const { dirPath, category } = event.data;
  const filePath = join(dirPath, INDEX_MD);

  if (await fileExists(filePath)) {
    return;
  }

  const label = startCase(category);
  const content = `---\ntitle: "${label}"\n---\n\n`;
  await ensureDir(dirPath);
  await saveFile(filePath, content);
};

/**
 * Hook that appends a link to the entity's page in the index file after rendering type entities.
 * 
 * This hook is triggered after a GraphQL type entity is rendered. 
 * It checks if an index file exists in the same directory as the 
 * rendered entity, and if so, appends a markdown link to the entity's page.
 */
const afterRenderTypeEntitiesHook = async (event) => {
  const { filePath, name } = event.data;
  const indexFilePath = resolve(dirname(filePath), INDEX_MD);
  const pageFileName = basename(filePath);
  if (await fileExists(indexFilePath)) {
    const entryLine = `- [${name}](./${pageFileName})\n`;
    await appendFile(indexFilePath, entryLine);
  }
};

export { 
  beforeGenerateIndexMetafileHook, 
  afterRenderTypeEntitiesHook 
};
```

## Display response types for operations

You can use this hook to automatically add the response type's SDL (Schema Definition Language) after each GraphQL operation (query, mutation, subscription).

This is useful when you want your documentation to show not just the operation signature but also the structure of the data it returns.

**Before (default output):**

```graphql
query user(id: ID!): User
```

**After (with hook):**

The hook appends a "Response Type" section after the operation's code block:

```graphql
query user(id: ID!): User
```

**Response Type**

```graphql
type User {
  id: ID!
  name: String!
  email: String
  posts: [Post!]!
}
```

Declare the custom module in GraphQL-Markdown configuration `mdxParser: "./custom-mdx.mjs"`.

```js title="custom-mdx.mjs"

  isOperation, 
  isScalarType, 
  getNamedType 
} from "@graphql-markdown/graphql";

/**
 * Hook that adds the response type's SDL after operation code blocks.
 *
 * This hook is executed after generating the code block for a GraphQL type.
 * For operations (queries, mutations, subscriptions), it appends a second
 * code block showing the structure of the return type.
 */
const afterPrintCodeHook = async (event) => {
  const { type, options } = event.data;

  // Only process operations (types with a `type` property for return type)
  if (!isOperation(type)) {
    return;
  }

  // Get the unwrapped return type (removes NonNull and List wrappers)
  const returnType = getNamedType(type.type);
  if (!returnType) {
    return;
  }

  // Skip scalar types - they don't need expanded documentation
  if (isScalarType(returnType)) {
    return;
  }

  // Generate the SDL code block for the return type
  const returnTypeCode = Printer.printCode(returnType, options);

  if (returnTypeCode) {
    event.output = `${event.output}\n\n### Response Type\n\n${returnTypeCode}`;
  }
};

export { afterPrintCodeHook };
```

:::tip

You can customize the heading level or text by changing `### Response Type` to match your documentation style.

:::

:::note

The `getNamedType` function from `@graphql-markdown/graphql` unwraps GraphQL type wrappers like `NonNull` and `List`. For example, `[User!]!` becomes `User`.

:::

## Reorder or hide sections before page composition

Use `beforeComposePageTypeHook` to customize the final section order for each type page. This is the recommended approach for section visibility and ordering.

```js title="custom-mdx.mjs"
const beforeComposePageTypeHook = async (event) => {
  // Hide the generated code section
  event.output = event.output.filter((key) => key !== "code");

  // Move "relations" before "metadata" when both are present
  const relationsIndex = event.output.indexOf("relations");
  const metadataIndex = event.output.indexOf("metadata");

  if (relationsIndex > -1 && metadataIndex > -1 && relationsIndex > metadataIndex) {
    event.output.splice(relationsIndex, 1);
    event.output.splice(metadataIndex, 0, "relations");
  }
};

export { beforeComposePageTypeHook };
```

---

## Integration with Frameworks


This guide provides examples for integrating GraphQL-Markdown with popular documentation frameworks.

## General Integration Approach

Most documentation frameworks allow you to generate documentation during the build process. You can integrate GraphQL-Markdown by creating a script that runs before your documentation build.

### Basic Integration Example

```js

const config = {
  schema: './schema.graphql',
  rootPath: './docs',
};

await runGraphQLMarkdown(config);
```

## Custom MDX Formatter

When integrating with frameworks other than Docusaurus, you'll need to create a custom MDX module to format documentation elements (badges, admonitions, etc.) using your framework's components.

### MDX Module Structure

A custom MDX module can export individual formatter functions:

| Export                     | Type                                                               | Description                                      |
| -------------------------- | ------------------------------------------------------------------ | ------------------------------------------------ |
| `formatMDXBadge`           | `(badge: { text, classname? }) => string`                          | Format type badges (deprecated, required, etc.)  |
| `formatMDXAdmonition`      | `(admonition: { text, title, type, icon? }, meta?) => string`      | Format callout/warning blocks                    |
| `formatMDXBullet`          | `(text?: string) => string`                                        | Format bullet point separators                   |
| `formatMDXDetails`         | `(option: { dataOpen, dataClose? }) => string`                     | Format collapsible sections                      |
| `formatMDXFrontmatter`     | `(props?, formatted?: string[]) => string`                         | Format page frontmatter                          |
| `formatMDXLink`            | `(link: { text, url }) => { text, url }`                           | Transform type links                             |
| `formatMDXNameEntity`      | `(name: string, parentType?: string) => string`                    | Format named entity references                   |
| `formatMDXSpecifiedByLink` | `(url: string) => string`                                          | Format scalar specification links                |

:::warning[`formatMDXDetails` contract]

The string returned by `formatMDXDetails` **must** contain a single `\r` (carriage return) character as a delimiter between the opening part and the closing part. The printer splits on `"\r"` to wrap generated content inside the collapsible element, so reserve `\r` only for that separator and use `\n` for all regular line breaks inside the returned string.

Do **not** use CRLF (`\r\n`) for normal line endings in `formatMDXDetails`, because any extra `\r` characters will also be treated as delimiters.

```js
// ✅ correct — use \n for normal line breaks and a single standalone \r as the delimiter
export const formatMDXDetails = ({ dataOpen }) =>
  `\n\n<MyDetails label="${dataOpen}">\n\r</MyDetails>\n\n`;

// ❌ incorrect — no \r means the closing tag is lost and items render outside
export const formatMDXDetails = ({ dataOpen }) =>
  `\n\n<MyDetails label="${dataOpen}">\n</MyDetails>\n\n`;

// ❌ incorrect — CRLF introduces extra \r characters that break result.split("\r")
export const formatMDXDetails = ({ dataOpen }) =>
  `\r\n\r\n<MyDetails label="${dataOpen}">\r\n\r</MyDetails>\r\n\r\n`;
```

:::

Additionally, the module can export:

| Export            | Type     | Description                                          |
| ----------------- | -------- | ---------------------------------------------------- |
| `mdxDeclaration`  | `string` | Import statements prepended to generated files       |
| `mdxExtension`    | `string` | Custom file extension (defaults to `.mdx`)           |

:::tip
You only need to export the formatter functions your framework requires. Any missing functions will use the default HTML-like implementation.
:::

### Lifecycle Hooks

The custom MDX module can also export lifecycle hooks to customize the generation process. See **[Hooks Recipes](/docs/advanced/hook-recipes#available-hooks)** for the full hook reference and usage examples.

## Framework-Specific Integration

### Docusaurus

The official [Docusaurus](https://docusaurus.io/) integration is available as a dedicated package:

:::info[Docusaurus default details output]

With the default `@graphql-markdown/docusaurus/mdx` parser, collapsible sections are emitted as native `<details>/<summary>` markup.
Custom summary labels are rendered with open/closed spans and toggled with CSS (`data-collapsed` and `[open]` selectors), so no custom `<Details>` React component is required.

:::

```js
const path = require('node:path');

module.exports = {
  // ... other docusaurus config
  plugins: [
    [
      '@graphql-markdown/docusaurus',
      {
        schema: path.join(__dirname, 'schema.graphql'),
        rootPath: path.join(__dirname, 'docs'),
        baseURL: 'api',
      },
    ],
  ],
};
```

For more details, check the [@graphql-markdown/docusaurus](https://github.com/graphql-markdown/graphql-markdown/tree/main/packages/docusaurus) package.

### Astro Starlight

For [Astro Starlight](https://starlight.astro.build/) integration, create a custom MDX module:

```js
// src/modules/astro-mdx.cjs

/**
 * Import statement prepended to every generated MDX file.
 */
const mdxDeclaration = `import { Aside, Badge } from '@astrojs/starlight/components';`;

/**
 * Optional: Custom file extension for generated files.
 */
const mdxExtension = ".mdx";

/**
 * Format badge elements (e.g., "deprecated", "required")
 */
const formatMDXBadge = ({ text, classname }) => {
  const variant = classname === "DEPRECATED" ? 'caution' : 'default';
  return `<Badge variant="${variant}" text="${text}"/>`;
};

/**
 * Format admonition/callout blocks (warnings, notes, tips)
 */
const formatMDXAdmonition = ({ text, title, type }, meta) => {
  const asideType = type === "warning" ? "caution" : "note";
  return `<Aside type="${asideType}" title="${title}">${text}</Aside>`;
};

module.exports = {
  mdxDeclaration,
  mdxExtension,
  formatMDXBadge,
  formatMDXAdmonition,
};
```

See complete implementation: [demo-astro-starlight](https://github.com/graphql-markdown/demo-astro-starlight)

### Next.js with Fumadocs

For Next.js using [Fumadocs](https://www.fumadocs.dev/), create a custom MDX module:

```js
// lib/fumadocs-mdx.cjs
const mdxDeclaration = `

`;

/**
 * Format badge elements
 */
const formatMDXBadge = ({ text, classname }) => {
  const color = classname === "DEPRECATED" ? 'warning' : 'info';
  return `<Chip color="${color}" label="${text}" size="small" variant="outlined"/>`;
};

/**
 * Format admonition/callout blocks
 */
const formatMDXAdmonition = ({ text, title, type }, meta) => {
  const calloutType = type === "warning" ? "warn" : "info";
  return `<Callout type="${calloutType}" title="${title}">${text}</Callout>`;
};

module.exports = {
  mdxDeclaration,
  formatMDXBadge,
  formatMDXAdmonition,
};
```

See complete implementation: [demo-nextjs-fumadocs](https://github.com/graphql-markdown/demo-nextjs-fumadocs)

### Vocs

For [Vocs](https://vocs.dev/) integration, create a custom MDX module:

```js
// lib/vocs-mdx.cjs
const mdxDeclaration = `

export const Bullet = () => <>&nbsp;●&nbsp;</>
`;

/**
 * Format badge elements
 */
const formatMDXBadge = ({ text, classname }) => {
  const color = classname === "DEPRECATED" ? 'warning' : 'info';
  return `<Chip color="${color}" label="${text}" size="small" variant="outlined"/>`;
};

/**
 * Format admonition/callout blocks
 */
const formatMDXAdmonition = ({ text, title, type }, meta) => {
  const calloutType = type === "warning" ? "warning" : "info";
  return `:::${calloutType}[${title}]${text}:::`;
};

/**
 * Format bullet point separators using custom Bullet component
 */
const formatMDXBullet = (text = "") => {
  return `<Bullet/>${text}`;
};

module.exports = {
  mdxDeclaration,
  formatMDXBadge,
  formatMDXAdmonition,
  formatMDXBullet,
};
```

See complete implementation: [demo-vite-vocs](https://github.com/graphql-markdown/demo-vite-vocs)

### VitePress

For [VitePress](https://vitepress.dev/) support, check the package **[graphql-markdown-vitepress](https://www.npmjs.com/package/graphql-markdown-vitepress)**.

---

## Namespaced operations


Grouping also works with namespaced operations (for example, `Query.analytics.*`, `Mutation.admin.*`, or `Subscription.events.*`).

If a root operation returns a namespace object, nested fields are generated as operation pages.

Namespace object type names must follow the corresponding operation suffix convention (`*Query`, `*Mutation`, `*Subscription`).

```graphql
type Query {
  analytics: AnalyticsQuery @doc(category: "Grade")
}

type AnalyticsQuery @doc(category: "Grade") {
  semesterGPA(semesterId: ID!): Int @doc(category: "Grade")
  coursesByDepartment(departmentId: ID!): [Course!]! @doc(category: "Course")
}
```

Generated operation pages include nested paths such as:

- `operations/queries/analytics/semester-gpa`
- `operations/queries/analytics/courses-by-department`

When [`groupByDirective`](/docs/advanced/group-by-directive) is enabled, these namespaced operations are still grouped by their directive category.

Generated code snippet for these namespaced operations will be wrapped in the namespace:

```graphql
# highlight-next-line
analytics {
  coursesByDepartment(
    departmentId: ID!
  ): [Course!]!
}
```

## Disable namespace wrapping with hooks

If you want to keep nested output paths but render operation code blocks without the namespace wrapper, use `beforePrintCodeHook` in your custom MDX module.

This hook runs before the code block is generated, so you can clear `operationNamespaceParts` only for the printed snippet.

```js title="custom-mdx.mjs"

const beforePrintCodeHook = async (event) => {
  const { type } = event.data;

  if (!isOperation(type)) {
    return;
  }

  // highlight-next-line
  event.data.options.operationNamespaceParts = null;
};

export { beforePrintCodeHook };
```

Then register the module with `mdxParser` as described in [Hooks Recipes](/docs/advanced/hook-recipes) and [Integration with Frameworks](/docs/advanced/integration-with-frameworks).

With this hook enabled, a namespaced operation page can still be generated at `operations/queries/analytics/courses-by-department`, but its code block will render without the namespace wrapper:

```graphql
coursesByDepartment(
  departmentId: ID!
): [Course!]!
```

---

## Schema loading


GraphQL-Markdown use external loaders for loading GraphQL schemas (see [full list](https://github.com/ardatan/graphql-tools/tree/master/packages/loaders)).

You can declare as many loaders as you need using a `LoaderOption` map:

```ts
// highlight-start
type LoaderOption = {
  [name: ClassName]: PackageName | PackageConfig;
};
// highlight-end

type PackageName = string & { _opaque: typeof PackageName };

type ClassName = string & { _opaque: typeof ClassName };

type PackageConfig = {
  module: PackageName;
  options?: PackageOptionsConfig;
};

type RootTypes = { query?: string; mutation?: string; subscription?: string };

type PackageOptionsConfig = BaseLoaderOptions & RootTypes;
```

## Local schema (file)

Use `@graphql-tools/graphql-file-loader` if you want to load a local schema:

```shell title="shell"
npm install @graphql-tools/graphql-file-loader
```

Once done, you can declare the loader in `@graphql-markdown/docusaurus` configuration:

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // ... other options
      loaders: {
        GraphQLFileLoader: "@graphql-tools/graphql-file-loader"
      }
    },
  ],
],
```

## Remote schema (url)

Use `@graphql-tools/url-loader`, if you want to load a schema from a URL:

```shell title="shell"
npm install @graphql-tools/url-loader
```

Once done, you can declare the loader in `@graphql-markdown/docusaurus` configuration:

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // ... other options
      loaders: {
        UrlLoader: {
          module: "@graphql-tools/url-loader",
          options: {
            headers: {
              Authorization: "<API_KEY>" // replace with your key if the gateway needs an auth key
             }
          }
        }
      }
    },
  ],
],
```

:::tip

See our [Troubleshooting section](/docs/troubleshooting) in case of error ['UrlLoader' does not exist in type 'LoaderOption'.ts](/docs/troubleshooting#urlloader-does-not-exist-in-type-loaderoptionts).

:::

## Code-first schema (TypeScript/JavaScript)

For teams using a code-first approach, use `@graphql-tools/code-file-loader` to load a schema exported directly from a TypeScript or JavaScript file:

```shell title="shell"
npm install @graphql-tools/code-file-loader
```

Once done, you can declare the loader in `@graphql-markdown/docusaurus` configuration:

```js title="docusaurus.config.js"
plugins: [
  [
    "@graphql-markdown/docusaurus",
    /** @type {import('@graphql-markdown/types').ConfigOptions} */
    {
      // ... other options
      schema: "./src/**/graphql/*.ts",
      loaders: {
        CodeFileLoader: "@graphql-tools/code-file-loader"
      }
    },
  ],
],
```

The schema file must export a `GraphQLSchema` instance as its default or named export. This works with any code-first library that produces a `GraphQLSchema` — including `makeExecutableSchema` (graphql-tools), [Pothos](https://pothos-graphql.dev/), [TypeGraphQL](https://typegraphql.com/), and [NestJS](https://docs.nestjs.com/graphql/quick-start).

---

## Settings


All settings can be set via plugin options in your config file and overridden with CLI flags. See [configuration](/docs/configuration) for the different config methods.

## `--config`

Print the resolved configuration used for generating documentation. This CLI flag is used for debugging purposes.

| Setting | CLI flag   | Default |
| :------ | :--------- | :------ |
|         | `--config` | `null`  |

Example:

```bash
npx docusaurus graphql-to-doc --config
```

## `baseURL`

The base URL used by Docusaurus. It will also be used as the folder name under [`rootPath`](#rootpath) for the generated documentation.

| Setting   | CLI flag               | Default  |
| --------- | ---------------------- | -------- |
| `baseURL` | `-b, --base <baseURL>` | `schema` |

## `customDirective`

Use this option to render directive information for types (see [custom directive](/docs/advanced/custom-directive)).

| Setting           | CLI flag        | Default     |
| ----------------- | --------------- | ----------- |
| `customDirective` | _not supported_ | `undefined` |

## `diffMethod`

The method to be used for identifying changes in the schema for triggering the documentation generation.

The possible values are:

- `FORCE`: skip diff, always generate documentation, also triggered by [`force`](#force) setting.
- `NONE`: skip diff (same as `FORCE`).
- `SCHEMA-DIFF`: use [GraphQL Inspector](https://graphql-inspector.com) to identify changes in the schema (including description).
- `SCHEMA-HASH`: use the schema SHA-256 hash for identifying changes in the schema (this method is sensitive to white spaces and invisible characters).

| Setting      | CLI flag                  | Default |
| ------------ | ------------------------- | ------- |
| `diffMethod` | `-d, --diff <diffMethod>` | `NONE`  |

:::info

The package `@graphql-markdown/diff` is required for using `diffMethod`.
If the package is missing, then the change detection is always skipped.

```shell
npm install @graphql-markdown/diff
```

:::

## `docOptions`

Use these options to tweak some of the static documentation generator features:

- `categorySort`: control how categories are sorted in the sidebar. Can be `"natural"` for alphabetical sorting or a custom compare function. When enabled, folder names are automatically prefixed with zero-padded order numbers (e.g., `01-objects`, `02-queries`). When not set, the order depends on document generator folders sorting and no prefixes are added.
- `frontMatter`: set custom front matter entries as key/value. If set to `false`, then it will disable the frontmatter and print a level 1 title as the page title.
- `index`: enable/disable the index page for categories/groups, see [Docusaurus documentation](https://docusaurus.io/docs/sidebar/items#generated-index-page) &mdash; **ONLY FOR DOCUSAURUS**
- `sectionHeaderId`: enable/disable the generation of custom header IDs for permalinks. Conceptually this uses the syntax `### Section {#ID}`, but the generated MDX will escape the braces as in `### Section \{#id\}` so that MDX does not treat `{...}` as an expression.

| Setting                      | CLI flag        | Default |
| ---------------------------- | --------------- | ------- |
| `docOptions.categorySort`    | _not supported_ | -       |
| `docOptions.frontMatter`     | _not supported_ | `{}`    |
| `docOptions.index`           | `--index`       | `false` |
| `docOptions.sectionHeaderId` | `--noSectionId` | `true`  |

```js title="docusaurus.config.js"
plugins: [
    [
      "@graphql-markdown/docusaurus",
       /** @type {import('@graphql-markdown/types').ConfigOptions} */
       {
        schema: "./schema/swapi.graphql",
        rootPath: "./docs",
        baseURL: "swapi",
        homepage: "./docs/swapi.md",
        // highlight-start
        docOptions: {
          frontMatter: {
            pagination_next: null, // disable page navigation next
            pagination_prev: null, // disable page navigation previous
            hide_table_of_contents: true, // disable page table of content
          },
          index: true, // enable generated index pages, same as CLI flag --index
          categorySort: "natural", // sort categories alphabetically and prefix with order numbers (01-objects, 02-queries, etc.)
          sectionHeaderId: false, // disable custom section header IDs (restores previous behavior)
        },
        // highlight-end
        loaders: {
          GraphQLFileLoader: "@graphql-tools/graphql-file-loader" // local file schema
        },
      },
    ],
  ],
```

:::info[Compatibility between options]

The `categorySort` option works seamlessly with:

- **`hierarchy` option**: Works with all hierarchy types (`api`, `entity`, `flat`)
- **`groupByDirective` option**: When using custom groups, categories are sorted based on group names and prefixed accordingly
- **`deprecated` option**: Deprecated categories are sorted along with other categories

**Example with groupByDirective:**

```js
docOptions: {
  categorySort: "natural",      // Sort groups alphabetically and prefix with order numbers
},
groupByDirective: {
  directive: "doc",
  field: "category",
  fallback: "Common",
}
```

This generates folder names like: `01-common`, `02-internal`, `03-public`

:::

## `force`

Force generating documentation in an empty folder and set [`diffMethod`](#diffmethod) to `FORCE`. If the folder located at `rootPath/baseURL` is not empty, then the plugin will delete the folder recursively and recreate it.

| Setting | CLI flag      | Default |
| ------- | ------------- | ------- |
| `force` | `-f, --force` | `false` |

## `groupByDirective`

Use a GraphQL directive for creating documentation categories (see [documentation categories](/docs/advanced/group-by-directive)).

| Setting            | CLI flag                                                                        | Default     |
| ------------------ | ------------------------------------------------------------------------------- | ----------- |
| `groupByDirective` | <code>-gdb, --groupByDirective &lt;&#64;directive(field&#124;=fallback)></code> | `undefined` |

## `homepage`

The location of the landing page to be used for the documentation, relative to the current workspace (see [custom homepage](/docs/advanced/homepage)). The file will be copied to the root folder of the generated documentation.

The plugin provides a default page in `assets/generated`.

| Setting    | CLI flag                    | Default        |
| ---------- | --------------------------- | -------------- |
| `homepage` | `-h, --homepage <homepage>` | `generated.md` |

:::tip

Set `homepage: false` to disable the homepage generation.

:::

:::info

The GraphQL-Markdown template for Docusaurus provides a customized homepage located at `static/index.md`.

:::

## `linkRoot`

The root for links in documentation. It depends on the entry for the schema main page in the Docusaurus sidebar.

| Setting    | CLI flag                | Default |
| ---------- | ----------------------- | ------- |
| `linkRoot` | `-l, --link <linkRoot>` | `/`     |

## `loaders`

GraphQL schema loaders to use (see [schema loading](/docs/advanced/schema-loading)).

| Setting   | CLI flag        | Default |
| --------- | --------------- | ------- |
| `loaders` | _not supported_ | `{ }`   |

## `mdxParser`

Provide a custom module for formatting MDX content. This allows integration with frameworks other than Docusaurus by defining custom formatter functions.

| Setting     | CLI flag      | Default                            |
| ----------- | ------------- | ---------------------------------- |
| `mdxParser` | `--mdxParser` | `@graphql-markdown/docusaurus/mdx` |

The custom module can export individual formatter functions:

| Export                     | Type                                      | Description                       |
| -------------------------- | ----------------------------------------- | --------------------------------- |
| `formatMDXBadge`           | `(badge: { text, classname? }) => string` | Format type badges                |
| `formatMDXAdmonition`      | `(admonition, meta?) => string`           | Format callout/warning blocks     |
| `formatMDXBullet`          | `(text?: string) => string`               | Format bullet point separators    |
| `formatMDXDetails`         | `(option) => string`                      | Format collapsible sections       |
| `formatMDXFrontmatter`     | `(props?, formatted?) => string`          | Format page frontmatter           |
| `formatMDXLink`            | `(link) => { text, url }`                 | Transform type links              |
| `formatMDXNameEntity`      | `(name, parentType?) => string`           | Format named entity references    |
| `formatMDXSpecifiedByLink` | `(url) => string`                         | Format scalar specification links |

For detailed examples on formatter functions, see **[Integration with Frameworks](/docs/advanced/integration-with-frameworks)**.

Additionally, the module can export:

| Export           | Type     | Description                                    |
| ---------------- | -------- | ---------------------------------------------- |
| `mdxDeclaration` | `string` | Import statements prepended to generated files |
| `mdxExtension`   | `string` | Custom file extension (defaults to `.mdx`)     |

The custom module can also export lifecycle hooks for customizing the generation process, see **[Hooks Recipes](/docs/advanced/hook-recipes)**.

```js title="docusaurus.config.js"
plugins: [
    [
      "@graphql-markdown/docusaurus",
       /** @type {import('@graphql-markdown/types').ConfigOptions} */
       {
        schema: "./schema/swapi.graphql",
        rootPath: "./docs",
        baseURL: "swapi",
        homepage: "./docs/swapi.md",
        // highlight-start
        mdxParser: "./lib/custom-mdx.cjs",
        // highlight-end
        loaders: {
          GraphQLFileLoader: "@graphql-tools/graphql-file-loader" // local file schema
        }
      },
    ],
  ],
```

## `metatags`

Set page metadata in `<html>`, `<head>` using [Docusaurus head metadata](https://docusaurus.io/docs/markdown-features/head-metadata).

Meta tags are provided as a list of metadata objects, eg `[{ name: "robots", content: "noindex" }]` for `<meta name="robots" content="noindex" />`.

| Setting    | CLI flag        | Default |
| ---------- | --------------- | ------- |
| `metatags` | _not supported_ | `[]`    |

```js title="docusaurus.config.js"
plugins: [
    [
      "@graphql-markdown/docusaurus",
       /** @type {import('@graphql-markdown/types').ConfigOptions} */
       {
        schema: "./schema/swapi.graphql",
        rootPath: "./docs",
        baseURL: "swapi",
        homepage: "./docs/swapi.md",
        // highlight-start
        metatags: [
          { name: "robots", content: "noindex" }, // <meta name="robots" content="noindex" />
          { charset: "utf-8" }, // <meta charset="utf-8" />
        ],
        // highlight-end
        loaders: {
          GraphQLFileLoader: "@graphql-tools/graphql-file-loader" // local file schema
        }
      },
    ],
  ],
```

## `onlyDocDirective`

The schema directive/s is used for selecting types to be rendered in the documentation.

The CLI flag supports multiple values separated by a space character, eg `--only @stable @beta`.

| Setting            | CLI flag                 | Default |
| ------------------ | ------------------------ | ------- |
| `onlyDocDirective` | `--only <@directive...>` | `[]`    |

See also [`skipDocDirective`](#skipdocdirective).

:::info

It only applies to types with a location compatible with the directive, i.e. if the `onlyDocDirective` cannot be applied to a type (e.g. `ENUM`), then the type will be displayed.

:::

## `printTypeOptions`

Use these options to toggle the type of information rendered on pages:

- `codeSection` (deprecated): display type code section. Prefer `beforeComposePageTypeHook` and remove `"code"` from `event.output`.
- `deprecated`: option for displaying deprecated entities (fields, values, operations).
  - `default`: deprecated entities are displayed with other entities.
  - `group`: deprecated entities are grouped.
  - `skip`: deprecated entities are not displayed (same as [`skipDocDirective`](#skipdocdirective)).
- `exampleSection`: configure example rendering based on directive data (see [Examples](/docs/advanced/examples)).
  - `printTypeOptions.exampleSection: { ... }` is the recommended configuration format.
  - `printTypeOptions.exampleSection: boolean` is deprecated; prefer `beforeComposePageTypeHook` and remove `"example"` from `event.output`.
- `hierarchy`: option for type folder structure:
  - `api`: folder structure by operations (`Operations` group) and types `Types` group based on GraphQL entity types.
  - `entity`: folder structure by GraphQL entity types (eg. queries, mutations, scalars, objects...).
  - `flat`: no folder structure (override [`groupByDirective`](#groupbydirective)).
  - _Namespaced operations are supported by default and generated as nested operation paths (See [Namespaced Operations](/docs/advanced/namespaced-operations))._
- `parentTypePrefix`: prefix field names with the parent type name.
- `relatedTypeSection` (deprecated): display related type sections. Prefer `beforeComposePageTypeHook` and remove `"relations"` from `event.output`.
- `typeBadges`: add field type attributes badges.

| Setting                               | CLI flag                | Default   |
| ------------------------------------- | ----------------------- | --------- |
| `printTypeOptions.codeSection`        | `--noCode`              | `true`    |
| `printTypeOptions.deprecated`         | `--deprecated <option>` | `default` |
| `printTypeOptions.exampleSection`     | `--noExample`           | `false`   |
| `printTypeOptions.hierarchy`          | `--hierarchy`           | `api`     |
| `printTypeOptions.parentTypePrefix`   | `--noParentType`        | `true`    |
| `printTypeOptions.relatedTypeSection` | `--noRelatedType`       | `true`    |
| `printTypeOptions.typeBadges`         | `--noTypeBadges`        | `true`    |

:::warning

`printTypeOptions.codeSection`, `printTypeOptions.relatedTypeSection`, boolean `printTypeOptions.exampleSection`, and CLI flags `--noCode`, `--noRelatedType`, `--noExample` are deprecated and kept for backward compatibility.

Use [`beforeComposePageTypeHook`](/docs/advanced/hook-recipes) to control section visibility and order instead.

:::

```js title="docusaurus.config.js"
plugins: [
    [
      "@graphql-markdown/docusaurus",
       /** @type {import('@graphql-markdown/types').ConfigOptions} */
       {
        schema: "./schema/swapi.graphql",
        rootPath: "./docs",
        baseURL: "swapi",
        homepage: "./docs/swapi.md",
        // highlight-start
        printTypeOptions: {
          deprecated: "group", // group deprecated entities, same as CLI flag --deprecated group
          exampleSection: {
            field: "example", // use directive field for example rendering
          },
          hierarchy: "entity",  // disable type API grouping, same as CLI flag --hierarchy entity
          parentTypePrefix: false, // disable parent prefix, same as CLI flag --noParentType
          typeBadges: false, // disable type attribute badges, same as CLI flag --noTypeBadges
        },
        mdxParser: require.resolve("./custom-mdx.cjs"), // use hook-based section composition
        // highlight-end
        loaders: {
          GraphQLFileLoader: "@graphql-tools/graphql-file-loader" // local file schema
        }
      },
    ],
  ],
```

```js title="custom-mdx.cjs"
const DocusaurusMDX = require("@graphql-markdown/docusaurus/mdx");

const beforeComposePageTypeHook = async (event) => {
  // Hide code and relations sections
  event.output = event.output.filter((key) => key !== "code" && key !== "relations");
};

module.exports = {
  ...DocusaurusMDX,
  beforeComposePageTypeHook,
};
```

:::warning[hierarchy]

**If you upgraded to version [1.23.0](https://github.com/graphql-markdown/graphql-markdown/releases/tag/1.23.0) or higher**, then in some cases the old GraphQL documentation structure is not being removed.

To resolve this, you can regenerate the documentation using the [`force`](#force) setting, or use `hierarchy: "entity"` to keep the previous behavior.

:::

:::danger

Declaring a different option type in the CLI flag `hierarchy` and the config file `hierarchy` will generate an error.

:::

:::tip

`api` option for `hierarchy` can use customized group names (defaults are `operations` and `types`) by passing an object instead of `api` using the group name as key for the new name:

```js title="docusaurus.config.js"
plugins: [
    [
      "@graphql-markdown/docusaurus",
       /** @type {import('@graphql-markdown/types').ConfigOptions} */
       {
        // highlight-start
        printTypeOptions: {
          hierarchy: { // no customization 'hierarchy: "api"' (default)
            api: { // enable useApiGroup with custom groups name
              operations: "api", // rename the group 'operations' to 'api'
              //group 'types' left unchanged
            }
          }
        },
        // highlight-end
      },
    ],
  ],
```

:::

:::info

See **[customize deprecated sections](/docs/advanced/custom-deprecated-section)** to customize the rendering of `printTypeOptions.deprecated: "group"`.

:::

## `pretty`

Use [`prettier`](https://prettier.io) to format generated files.

| Setting  | CLI flag   | Default |
| -------- | ---------- | ------- |
| `pretty` | `--pretty` | `false` |

:::info

The `prettier` package has to be installed separately. If the package is not present locally, then the formatting will always be skipped.

:::

## `runOnBuild`

:::warning[DEPRECATED]

`runOnBuild` is deprecated and will be removed in a future release.

:::

When set to `true`, this option runs documentation generation during `docusaurus build`.

Prefer generating docs explicitly with the Docusaurus command `graphql-to-doc` before running the build.

```bash
npx docusaurus graphql-to-doc
npx docusaurus build
```

| Setting      | CLI flag | Default |
| ------------ | -------- | ------- |
| `runOnBuild` | n/a      | `false` |

## `rootPath`

The output root path for the generated documentation, relative to the current workspace.
It works with [`baseURL`](#baseurl), and the final path will be `rootPath/baseURL`.

| Setting    | CLI flag                | Default  |
| ---------- | ----------------------- | -------- |
| `rootPath` | `-r, --root <rootPath>` | `./docs` |

## `schema`

The GraphQL schema location.

| Setting  | CLI flag                | Default            |
| -------- | ----------------------- | ------------------ |
| `schema` | `-s, --schema <schema>` | `./schema.graphql` |

## `skipDocDirective`

The schema directive/s is used for skipping types from documentation.

The CLI flag supports multiple values separated by a space character, eg `--skip @noDoc @deprecated`.

| Setting            | CLI flag                 | Default |
| ------------------ | ------------------------ | ------- |
| `skipDocDirective` | `--skip <@directive...>` | `[]`    |

See also [`onlyDocDirective`](#onlydocdirective).

:::danger

Declaring the same type in both `onlyDocDirective` and `skipDocDirective` will generate an error.

:::

:::info

Types with `@deprecated` directive can also be skipped using the setting **[`printTypeOptions.deprecated: "skip"`](#printtypeoptions)** or the flag `--deprecated skip`.

:::

## `tmpDir`

The folder used for storing schema copy and signature is used by [`diffMethod`](#diffmethod) setting.

| Setting  | CLI flag             | Default          |
| -------- | -------------------- | ---------------- |
| `tmpDir` | `-t, --tmp <tmpDir>` | _OS temp folder_ |

---

## Troubleshooting


## Duplicate "graphql" modules cannot be used at the same time

Add a `resolutions` entry to your `package.json`:

```json title="package.json"
"resolutions": 
{
  "graphql": "16.9.0"
}
```

## Unable to find any GraphQL type definitions

There are several potential solutions:

1. Change the temporary folder location:
```js
{
  tmpDir: "./.docusaurus"
}
```

2. Disable schema diff feature:
```js
{
  diffMethod: "NONE" 
}
```

3. Check file permissions on the temporary directory

## Schema Loading Issues

1. Ensure required loaders are installed:
```shell
npm install @graphql-tools/url-loader @graphql-tools/json-file-loader
```

2. Verify loader configuration:
```js
{
  loaders: {
    UrlLoader: "@graphql-tools/url-loader",
    JsonFileLoader: "@graphql-tools/json-file-loader"
  }
}
```

## "UrlLoader" does not exist in type "LoaderOption".ts

*Reported in [#2213](https://github.com/graphql-markdown/graphql-markdown/issues/2213).*

```
Object literal may only specify known properties, and 'UrlLoader' does not exist in type 'LoaderOption'.ts(2353)
core.d.ts(128, 3): The expected type comes from property 'loaders' which is declared here on type 'ConfigOptions'
```

Cast the `loaders` as LoaderOption

```ts
loaders: {
  UrlLoader: {
    module: "@graphql-tools/url-loader",
    options: {
      headers: {
        Authorization: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9",
      },
    },
  },
} as LoaderOption,
```

## Memory Issues During Generation

For large schemas, try:

1. Increase Node.js memory limit:
```shell
NODE_OPTIONS=--max-old-space-size=4096 npx docusaurus graphql-to-doc
```

## Getting Help

If you're still having issues:

1. Check the [GitHub issues](https://github.com/graphql-markdown/graphql-markdown/issues)
2. File a new issue with:
   - Your configuration
   - Schema size/complexity
   - Error messages
   - Node.js and package versions

---

## introspection

Library for introspecting a GraphQL schema.
The entry point method is [getSchemaMap](#getschemamap).

## IntrospectionError \{#introspectionerror\}

Defined in: packages/graphql/src/introspection.ts:51

### Example

```ts

```

### Extends

- `Error`

### Constructors

#### Constructor

```ts
new IntrospectionError(message?): IntrospectionError;
```

Defined in: node_modules/.bun/typescript@6.0.3/node_modules/typescript/lib/lib.es5.d.ts:1080

##### Parameters

###### message?

`string`

##### Returns

[`IntrospectionError`](#introspectionerror)

##### Inherited from

```ts
Error.constructor;
```

#### Constructor

```ts
new IntrospectionError(message?, options?): IntrospectionError;
```

Defined in: node_modules/.bun/typescript@6.0.3/node_modules/typescript/lib/lib.es5.d.ts:1080

##### Parameters

###### message?

`string`

###### options?

`ErrorOptions`

##### Returns

[`IntrospectionError`](#introspectionerror)

##### Inherited from

```ts
Error.constructor;
```

---

## \_getFields() \{#\_getfields\}

```ts
function _getFields<T, V>(
  type,
  processor?,
  fallback?,
): Record<string, unknown> | V;
```

Defined in: packages/graphql/src/introspection.ts:312

**`Internal`**

Returns the fields from a GraphQL schema type.

see [getOperation](#getoperation), [getFields](#getfields)

### Type Parameters

#### T

`T`

#### V

`V`

### Parameters

#### type

`T`

the GraphQL schema type to parse.

#### processor?

(`fieldMap`) => `V`

optional callback function to parse the fields map.

#### fallback?

`V`

optional fallback value, `undefined` if not set.

### Returns

`Record`&lt;`string`, `unknown`&gt; \| `V`

a map of fields as k/v records, or `fallback` value if no fields available.

---

## getDirective() \{#getdirective\}

```ts
function getDirective(entity, directives): GraphQLDirective[];
```

Defined in: packages/graphql/src/introspection.ts:223

Returns a schema entity's list of directives matching a defined set.

### Parameters

#### entity

`unknown`

a GraphQL schema entity.

#### directives

`Maybe`&lt;`GraphQLDirective`[]&gt;

a directive name or a list of directive names.

### Returns

`GraphQLDirective`[]

a list of GraphQL directives matching the set, else `false`.

---

## getDirectiveLocationForASTPath() \{#getdirectivelocationforastpath\}

```ts
function getDirectiveLocationForASTPath(appliedTo): DirectiveLocation;
```

Defined in: packages/graphql/src/introspection.ts:122

### Parameters

#### appliedTo

`Maybe`&lt;`ASTNode`&gt;

### Returns

`DirectiveLocation`

---

## getFields() \{#getfields\}

```ts
function getFields(type): unknown[];
```

Defined in: packages/graphql/src/introspection.ts:576

Returns fields map for a GraphQL schema type.

see [getSchemaMap](#getschemamap)

### Parameters

#### type

`unknown`

the GraphQL schema type to parse.

### Returns

`unknown`[]

a list of fields of type object.

---

## getOperation() \{#getoperation\}

```ts
function getOperation(
  operationType?,
  operationKind?,
): Record<string, GraphQLOperationType>;
```

Defined in: packages/graphql/src/introspection.ts:539

**`Internal`**

Returns fields map for a GraphQL operation type (query, mutation, subscription...).

see [getSchemaMap](#getschemamap)

### Parameters

#### operationType?

`unknown`

the operation type to parse.

#### operationKind?

`Maybe`&lt;`OperationKind`&gt;

optional explicit operation kind.

### Returns

`Record`&lt;`string`, `GraphQLOperationType`&gt;

a map of fields as k/v records.

---

## getSchemaMap() \{#getschemamap\}

```ts
function getSchemaMap(schema): SchemaMap;
```

Defined in: packages/graphql/src/introspection.ts:654

Returns an introspection map of the GraphQL schema.
This is the entry point for GraphQL-Markdown schema parsing features.

### Parameters

#### schema

`Maybe`&lt;`GraphQLSchema`&gt;

a GraphQL schema.

### Returns

`SchemaMap`

a schema map by GraphQL entities (see SchemaEntity).

### Example

```js

const schema = buildSchema(`
  interface Record {
    id: String!
  }
  type StudyItem implements Record {
    id: String!
    subject: String!
    duration: Int!
  }
  type Query {
    getStudyItems(subject: String): [StudyItem!]
    getStudyItem(id: String!): StudyItem
  }
  type Mutation {
    addStudyItem(subject: String!, duration: Int!): StudyItem
  }
  type Subscription {
    listStudyItems: [StudyItem!]
  }
`);

const schemaTypeMap = getSchemaMap(schema);

// expected result: {
//   queries: {
//     getStudyItems: GraphQLField,
//     getStudyItem: GraphQLField,
//   },
//   mutations: {
//     addStudyItem: GraphQLField,
//   },
//   subscriptions: {
//     listStudyItems: GraphQLField,
//   }
//   directives: {
//     include: GraphQLDirective,
//     skip: GraphQLDirective,
//     deprecated: GraphQLDirective,
//     specifiedBy: GraphQLDirective,
//   objects: {
//     StudyItem: GraphQLObjectType,
//   unions: {},
//   interfaces: {
//     Record: GraphQLInterfaceType,
//   enums: {},
//   inputs: {},
//   scalars: {
//     String: GraphQLScalarType,
//     Int: GraphQLScalarType,
//     Boolean: GraphQLScalarType,
//   }
// }
```

---

## getTypeDirectiveArgValue() \{#gettypedirectiveargvalue\}

```ts
function getTypeDirectiveArgValue(
  directive,
  node,
  argName,
): Maybe<string | Record<string, unknown>>;
```

Defined in: packages/graphql/src/introspection.ts:284

Returns one directive's argument's value linked to a GraphQL schema type.
It calls [getTypeDirectiveValues](#gettypedirectivevalues) and returns a matching record.

### Parameters

#### directive

`GraphQLDirective`

a GraphQL directive defined in the schema.

#### node

`unknown`

the GraphQL schema type to parse.

#### argName

`string`

the name of the GraphQL directive argument to fetch the value from.

### Returns

`Maybe`&lt;`string` \| `Record`&lt;`string`, `unknown`&gt;&gt;

a record k/v with `argName` as key and the argument's value.

---

## getTypeDirectiveValues() \{#gettypedirectivevalues\}

```ts
function getTypeDirectiveValues(
  directive,
  type,
): Maybe<Record<string, unknown>>;
```

Defined in: packages/graphql/src/introspection.ts:253

Returns all directive's arguments' values linked to a GraphQL schema type.

### Parameters

#### directive

`GraphQLDirective`

a GraphQL directive defined in the schema.

#### type

`unknown`

the GraphQL schema type to parse.

### Returns

`Maybe`&lt;`Record`&lt;`string`, `unknown`&gt;&gt;

a record k/v with arguments' name as keys and arguments' value.

---

## getTypeFromSchema() \{#gettypefromschema\}

```ts
function getTypeFromSchema<T>(schema, type): Maybe<Record<string, T>>;
```

Defined in: packages/graphql/src/introspection.ts:67

**`Internal`**

Returns a map of GraphQL named types from a schema for a defined GraphQL type.
When parsing the entities, internal GraphQL entities (starting with `__`) are excluded.

### Type Parameters

#### T

`T`

### Parameters

#### schema

`Maybe`&lt;`GraphQLSchema`&gt;

a GraphQL schema.

#### type

`unknown`

a GraphQL type, eg `GraphQLObjectType`.

### Returns

`Maybe`&lt;`Record`&lt;`string`, `T`&gt;&gt;

a map of GraphQL named types for the matching GraphQL type, or `undefined` if no match.

### See

[getSchemaMap](#getschemamap)

---

## getTypeName() \{#gettypename\}

```ts
function getTypeName(type, defaultName?): string;
```

Defined in: packages/graphql/src/introspection.ts:374

Resolves the name of a GraphQL schema type.

### Parameters

#### type

`unknown`

the GraphQL schema type to parse.

#### defaultName?

`string` = `""`

optional fallback value if the name resolution fails.

### Returns

`string`

the type's name, or `defaultName`.

---

## hasAstNode() \{#hasastnode\}

```ts
function hasAstNode<T>(node): node is AstNodeType<T>;
```

Defined in: packages/graphql/src/introspection.ts:115

**`Internal`**

Type guard for type with an AST node property.

### Type Parameters

#### T

`T`

### Parameters

#### node

`T`

a GraphQL schema named type.

### Returns

`node is AstNodeType<T>`

`true` if the entity has an AST node property, else `false`.

---

## hasDirective() \{#hasdirective\}

```ts
function hasDirective(entity, directives, fallback?): boolean;
```

Defined in: packages/graphql/src/introspection.ts:188

Checks if a schema entity as a directive belonging to a defined set.

### Parameters

#### entity

`unknown`

a GraphQL schema entity.

#### directives

`Maybe`&lt;`GraphQLDirective`[]&gt;

a directive name or a list of directive names.

#### fallback?

`boolean` = `false`

default value if the entity type is not a valid location for directives.

### Returns

`boolean`

`true` if the entity has at least one directive matching, else `false`.

---

## isValidDirectiveLocation() \{#isvaliddirectivelocation\}

```ts
function isValidDirectiveLocation(entity, directive): boolean;
```

Defined in: packages/graphql/src/introspection.ts:167

Check if a directive can be applied to specific schema entity location.

### Parameters

#### entity

`unknown`

a GraphQL schema entity.

#### directive

`GraphQLDirective`

a directive name.

### Returns

`boolean`

`true` if the entity is a valid directive location, else `false`.

---

## cli

This module provides the CLI functionality for generating documentation from GraphQL schemas.
It exports utilities to run the documentation generator both programmatically and via CLI.

## See

[GraphQL Markdown Documentation](https://graphql-markdown.dev)

## GraphQLMarkdownCliType \{#graphqlmarkdownclitype\}

```ts
type GraphQLMarkdownCliType = CommanderStatic;
```

Defined in: index.ts:29

Type representing the GraphQL Markdown CLI.

### See

[GraphQL Markdown Documentation](https://graphql-markdown.dev)

---

## getGraphQLMarkdownCli() \{#getgraphqlmarkdowncli\}

```ts
function getGraphQLMarkdownCli(
  options,
  loggerModule?,
  customMdxParser?,
): CommanderStatic;
```

Defined in: index.ts:84

Configures and returns the GraphQL Markdown CLI.

### Parameters

#### options

`GraphQLMarkdownCliOptions`

Options for configuring the GraphQL Markdown CLI.

#### loggerModule?

`string`

Optional logger module to use.

#### customMdxParser?

`string` \| `boolean`

Optional MDX parser configuration.

### Returns

`CommanderStatic`

The configured CLI instance.

### Example

```typescript
const cli = getGraphQLMarkdownCli({ id: "custom" }, "custom-logger", true);
await cli.parseAsync(process.argv);
```

---

## runGraphQLMarkdown() \{#rungraphqlmarkdown\}

```ts
function runGraphQLMarkdown(options, cliOptions, loggerModule?): Promise<void>;
```

Defined in: index.ts:47

Runs the GraphQL Markdown CLI to generate documentation from a GraphQL schema.

### Parameters

#### options

`GraphQLMarkdownCliOptions`

Options for configuring the GraphQL Markdown CLI.

#### cliOptions

`CliOptions`

Command-line options passed to the CLI.

#### loggerModule?

`string`

Optional logger module to use.

### Returns

`Promise`&lt;`void`&gt;

### Example

```typescript
await runGraphQLMarkdown(
  { id: "custom" },
  { schema: "./schema.graphql", root: "./docs" },
  "custom-logger",
);
```

---

## main

Entry point for the GraphQL Markdown CLI.
Loads configuration from graphql-config and sets up command-line interface.

## EXTENSION_NAME \{#extension_name\}

```ts
const EXTENSION_NAME: "graphql-markdown";
```

Defined in: main.ts:24

Name of the GraphQL Markdown extension for graphql-config

---

## graphQLConfigExtension \{#graphqlconfigextension\}

```ts
const graphQLConfigExtension: GraphQLExtensionDeclaration;
```

Defined in: main.ts:30

GraphQL config extension declaration for GraphQL Markdown

### Returns

Extension configuration object

---

## config

Configuration management for GraphQL Markdown.

This module handles all aspects of configuration including:

- Loading and merging configuration from multiple sources
- Validating configuration values
- Providing defaults for missing options
- Processing special configuration options (directives, deprecated items, etc)

The configuration follows this precedence (highest to lowest):

1. CLI arguments
2. Config file options
3. GraphQL Config options
4. Default values

## DeprecatedOption \{#deprecatedoption\}

Defined in: core/src/config.ts:102

Options for handling deprecated items in the schema.

- DEFAULT: Show deprecated items normally
- GROUP: Group deprecated items separately
- SKIP: Exclude deprecated items from documentation

### Example

```typescript
const deprecatedHandling = DeprecatedOption.GROUP;
```

### Enumeration Members

#### DEFAULT \{#default\}

```ts
DEFAULT: "default";
```

Defined in: core/src/config.ts:103

#### GROUP \{#group\}

```ts
GROUP: "group";
```

Defined in: core/src/config.ts:104

#### SKIP \{#skip\}

```ts
SKIP: "skip";
```

Defined in: core/src/config.ts:105

---

## DiffMethod \{#diffmethod\}

Defined in: core/src/config.ts:84

Diff methods used to determine how schema changes are processed.

- NONE: No diffing is performed
- FORCE: Force regeneration of documentation regardless of schema changes

### Example

```typescript
const diffMethod = DiffMethod.FORCE;
```

### Enumeration Members

#### FORCE \{#force\}

```ts
FORCE: "FORCE";
```

Defined in: core/src/config.ts:86

#### NONE \{#none\}

```ts
NONE: "NONE";
```

Defined in: core/src/config.ts:85

---

## TypeHierarchy \{#typehierarchy\}

Defined in: core/src/config.ts:66

Type hierarchy options for organizing schema documentation.

- API: Groups types by their role in the API (Query, Mutation, etc.)
- ENTITY: Groups types by their entity relationships
- FLAT: No grouping, all types in a flat structure

### Example

```typescript
const hierarchy = TypeHierarchy.API;
```

### Enumeration Members

#### API \{#api\}

```ts
API: "api";
```

Defined in: core/src/config.ts:67

#### ENTITY \{#entity\}

```ts
ENTITY: "entity";
```

Defined in: core/src/config.ts:68

#### FLAT \{#flat\}

```ts
FLAT: "flat";
```

Defined in: core/src/config.ts:69

---

## ASSET_HOMEPAGE_LOCATION \{#asset_homepage_location\}

```ts
const ASSET_HOMEPAGE_LOCATION: string;
```

Defined in: core/src/config.ts:123

Location of the default homepage template.

---

## DEFAULT_HIERARCHY \{#default_hierarchy\}

```ts
const DEFAULT_HIERARCHY: object;
```

Defined in: core/src/config.ts:134

Default hierarchy configuration using the API hierarchy type.

### Type Declaration

#### api \{#api-1\}

```ts
api: object = {};
```

---

## DEFAULT_OPTIONS \{#default_options\}

```ts
const DEFAULT_OPTIONS: Readonly<
  Pick<ConfigOptions, "customDirective" | "groupByDirective" | "loaders"> &
    Required<
      Omit<
        ConfigOptions,
        | "customDirective"
        | "groupByDirective"
        | "loaders"
        | "mdxParser"
        | "printTypeOptions"
      >
    >
> &
  object;
```

Defined in: core/src/config.ts:143

Default configuration options used when no user options are provided.
These values serve as fallbacks for any missing configuration.

### Type Declaration

#### printTypeOptions

```ts
printTypeOptions: Required<Omit<ConfigPrintTypeOptions, "hierarchy">> & object;
```

##### Type Declaration

###### hierarchy

```ts
hierarchy: Required<Pick<TypeHierarchyObjectType, API>>;
```

### See

Options for the complete configuration interface

---

## DOCS_URL \{#docs_url\}

```ts
const DOCS_URL: "https://graphql-markdown.dev/docs";
```

Defined in: core/src/config.ts:112

Documentation website URL for reference in error messages and help text.

---

## PACKAGE_NAME \{#package_name\}

```ts
const PACKAGE_NAME: "@graphql-markdown/docusaurus";
```

Defined in: core/src/config.ts:118

Default package name used for temporary directory creation and identification.

---

## buildConfig() \{#buildconfig\}

```ts
function buildConfig(configFileOpts, cliOpts?, id?): Promise<Options>;
```

Defined in: core/src/config.ts:820

### Parameters

#### configFileOpts

`Maybe`&lt;`ConfigOptions`&gt;

#### cliOpts?

`Maybe`&lt;`CliOptions`&gt;

#### id?

`Maybe`&lt;`string`&gt; = `"default"`

### Returns

`Promise`&lt;`Options`&gt;

---

## getCustomDirectives() \{#getcustomdirectives\}

```ts
function getCustomDirectives(
  customDirectiveOptions,
  skipDocDirective?,
): Maybe<CustomDirective>;
```

Defined in: core/src/config.ts:392

Processes custom directives, filtering out any that should be skipped.
Validates that each custom directive has the correct format with required functions.

### Parameters

#### customDirectiveOptions

`Maybe`&lt;`CustomDirective`&gt;

The custom directive configuration object

#### skipDocDirective?

`Maybe`&lt;`DirectiveName`[]&gt;

Array of directive names that should be skipped

### Returns

`Maybe`&lt;`CustomDirective`&gt;

The filtered custom directives object, or `undefined` if empty/invalid

### Throws

Error if a custom directive has an invalid format

### Example

```typescript
// Valid custom directive with descriptor function
const customDirectives = {
  example: {
    tag: (value) => `Example: ${value}`,
  },
  note: {
    descriptor: () => "Note items",
  },
};

// Filter out the "example" directive, keeping "note"
const filteredDirectives = getCustomDirectives(customDirectives, ["example"]);
console.log(filteredDirectives); // { note: { descriptor: [Function] } }

// Invalid format - will throw an error
getCustomDirectives({ example: { invalid: true } }, []);
// Error: Wrong format for plugin custom directive "example"...
```

### See

[DOCS_URL](#docs_url)/advanced/custom-directive for custom directive format documentation

---

## getDiffMethod() \{#getdiffmethod\}

```ts
function getDiffMethod(diff): TypeDiffMethod;
```

Defined in: core/src/config.ts:447

### Parameters

#### diff

`TypeDiffMethod`

### Returns

`TypeDiffMethod`

---

## getDocDirective() \{#getdocdirective\}

```ts
function getDocDirective(name): DirectiveName;
```

Defined in: core/src/config.ts:217

Retrieves a directive name from a string by parsing and validating the format.
Directive names should be prefixed with '@' (e.g., '@example').

### Parameters

#### name

`Maybe`&lt;`DirectiveName`&gt;

The directive name as a string, which should follow the format '@directiveName'

### Returns

`DirectiveName`

The validated directive name without the '@' prefix

### Throws

Error if the directive name format is invalid

### Example

```typescript
const directive = getDocDirective("@example");
console.log(directive); // "example"

// Invalid - will throw an error
getDocDirective("example"); // Error: Invalid "example"
```

---

## getDocOptions() \{#getdocoptions\}

```ts
function getDocOptions(cliOpts?, configOptions?): Required<ConfigDocOptions>;
```

Defined in: core/src/config.ts:486

Builds the document options by merging CLI options, config file options, and defaults.
Handles index generation flag and front matter configuration.

### Parameters

#### cliOpts?

`Maybe`&lt;`CliOptions` & `Omit`&lt;`DeprecatedCliOptions`, `"never"`&gt;&gt;

CLI options for document generation

#### configOptions?

`Maybe`&lt;`ConfigDocOptions` & `Omit`&lt;`DeprecatedConfigDocOptions`, `"never"`&gt;&gt;

Config file options for document generation

### Returns

`Required`&lt;`ConfigDocOptions`&gt;

The resolved document options with all required fields

### Example

```typescript
const cliOptions = { index: true };
const configOptions = { frontMatter: { sidebar_label: "API" } };

const docOptions = getDocOptions(cliOptions, configOptions);
console.log(docOptions);
// {
//   index: true,
//   frontMatter: { sidebar_label: 'API' }
// }
```

---

## getForcedDiffMethod() \{#getforceddiffmethod\}

```ts
function getForcedDiffMethod(): TypeDiffMethod;
```

Defined in: core/src/config.ts:437

Returns FORCE as the diff method.
This function is used when documentation should be forcefully regenerated.

### Returns

`TypeDiffMethod`

The FORCE diff method

### Example

```typescript
const method = getForcedDiffMethod();
console.log(method); // "FORCE"
```

### See

[DiffMethod](#diffmethod) for available diff methods

---

## getNormalizedDiffMethod() \{#getnormalizeddiffmethod\}

```ts
function getNormalizedDiffMethod(diff): TypeDiffMethod;
```

Defined in: core/src/config.ts:441

### Parameters

#### diff

`TypeDiffMethod`

### Returns

`TypeDiffMethod`

---

## getOnlyDocDirectives() \{#getonlydocdirectives\}

```ts
function getOnlyDocDirectives(cliOpts, configFileOpts): DirectiveName[];
```

Defined in: core/src/config.ts:248

Retrieves the list of "only" directives from CLI and config options.
These directives specify which schema elements should be included in the documentation.

### Parameters

#### cliOpts

`Maybe`&lt;`CliOptions`&gt;

CLI options containing "only" directives

#### configFileOpts

`Maybe`&lt;`Pick`&lt;`ConfigOptions`, `"onlyDocDirective"`&gt;&gt;

Config file options containing "onlyDocDirective"

### Returns

`DirectiveName`[]

An array of validated "only" directives (without '@' prefix)

### Example

```typescript
const cliOptions = { only: ["@example", "@internal"] };
const configOptions = { onlyDocDirective: ["@auth"] };

const onlyDirectives = getOnlyDocDirectives(cliOptions, configOptions);
console.log(onlyDirectives); // ["example", "internal", "auth"]
```

### See

[getDocDirective](#getdocdirective) for directive name validation

---

## getPrintTypeOptions() \{#getprinttypeoptions\}

```ts
function getPrintTypeOptions(
  cliOpts,
  configOptions,
): Required<ConfigPrintTypeOptions>;
```

Defined in: core/src/config.ts:671

Builds the print type options by merging CLI options, config file options, and defaults.
Handles various formatting options for type documentation.

### Parameters

#### cliOpts

`Maybe`&lt;`CliOptions` & `Omit`&lt;`DeprecatedCliOptions`, `"never"`&gt;&gt;

CLI options for print type configuration

#### configOptions

`Maybe`&lt;`ConfigPrintTypeOptions` & `Omit`&lt;`DeprecatedConfigPrintTypeOptions`, `"never"`&gt;&gt;

Config file options for print type configuration

### Returns

`Required`&lt;`ConfigPrintTypeOptions`&gt;

The resolved print type options with all required fields

### Example

```typescript
const cliOptions = { noCode: true, deprecated: "group" };
const configOptions = {
  exampleSection: true,
  hierarchy: "entity",
};

const printOptions = getPrintTypeOptions(cliOptions, configOptions);
console.log(printOptions);
// {
//   codeSection: false,  // Disabled via noCode CLI flag
//   deprecated: "group", // From CLI
//   exampleSection: true, // From config
//   parentTypePrefix: true, // Default value
//   relatedTypeSection: true, // Default value
//   typeBadges: true, // Default value
//   hierarchy: { entity: {} } // Parsed from config
// }
```

### See

- [DeprecatedOption](#deprecatedoption) for deprecated handling options
- [getTypeHierarchyOption](#gettypehierarchyoption) for hierarchy resolution

---

## getSkipDocDirectives() \{#getskipdocdirectives\}

```ts
function getSkipDocDirectives(cliOpts, configFileOpts): DirectiveName[];
```

Defined in: core/src/config.ts:283

Retrieves the list of "skip" directives from CLI and config options.
These directives specify which schema elements should be excluded from the documentation.
Additionally, if deprecated handling is set to SKIP, adds the "deprecated" directive.

### Parameters

#### cliOpts

`Maybe`&lt;`CliOptions`&gt;

CLI options containing "skip" directives

#### configFileOpts

`Maybe`&lt;`Pick`&lt;`ConfigOptions`, `"printTypeOptions"` \| `"skipDocDirective"`&gt;&gt;

Config file options containing "skipDocDirective" and potentially "printTypeOptions.deprecated"

### Returns

`DirectiveName`[]

An array of validated "skip" directives (without '@' prefix)

### Example

```typescript
const cliOptions = { skip: ["@internal"], deprecated: "skip" };
const configOptions = { skipDocDirective: ["@auth"] };

const skipDirectives = getSkipDocDirectives(cliOptions, configOptions);
console.log(skipDirectives); // ["internal", "auth", "deprecated"]
```

### See

- [getDocDirective](#getdocdirective) for directive name validation
- [DeprecatedOption](#deprecatedoption) for deprecated handling options

---

## getTypeHierarchyOption() \{#gettypehierarchyoption\}

```ts
function getTypeHierarchyOption(
  cliOption?,
  configOption?,
): Maybe<Partial<Record<TypeHierarchyValueType, TypeHierarchyTypeOptions>>>;
```

Defined in: core/src/config.ts:539

Resolves the type hierarchy configuration by merging CLI and config file options.
Validates that CLI and config don't specify conflicting hierarchy types.

### Parameters

#### cliOption?

`Maybe`&lt;`TypeHierarchyValueType`&gt;

The hierarchy option specified via CLI (string value)

#### configOption?

`Maybe`&lt;`TypeHierarchyType`&gt;

The hierarchy option from the config file (string or object)

### Returns

`Maybe`&lt;`Partial`&lt;`Record`&lt;`TypeHierarchyValueType`, `TypeHierarchyTypeOptions`&gt;&gt;&gt;

The resolved type hierarchy object

### Throws

Error if CLI and config specify conflicting hierarchy types

### Example

```typescript
// Using hierarchy from CLI (string format)
const hierarchy1 = getTypeHierarchyOption("api", undefined);
console.log(hierarchy1); // { api: {} }

// Using hierarchy from config (object format)
const hierarchy2 = getTypeHierarchyOption(undefined, {
  entity: { User: ["posts"] },
});
console.log(hierarchy2); // { entity: { User: ["posts"] } }

// Error case - conflicting hierarchies
getTypeHierarchyOption("api", { entity: {} });
// Error: Hierarchy option mismatch in CLI flag 'api' and config 'entity'
```

### See

[TypeHierarchy](#typehierarchy) for available hierarchy types

---

## getVisibilityDirectives() \{#getvisibilitydirectives\}

```ts
function getVisibilityDirectives(cliOpts, configFileOpts): object;
```

Defined in: core/src/config.ts:337

Combines and validates visibility directives (only and skip) from both CLI and config sources.
Ensures that no directive appears in both "only" and "skip" lists simultaneously.

### Parameters

#### cliOpts

`Maybe`&lt;`CliOptions`&gt;

CLI options containing "only" and "skip" directives

#### configFileOpts

`Maybe`&lt;`Pick`&lt;`ConfigOptions`, `"onlyDocDirective"` \| `"printTypeOptions"` \| `"skipDocDirective"`&gt;&gt;

Config file options containing directive configurations

### Returns

`object`

An object with validated "onlyDocDirective" and "skipDocDirective" arrays

#### onlyDocDirective

```ts
onlyDocDirective: DirectiveName[];
```

#### skipDocDirective

```ts
skipDocDirective: DirectiveName[];
```

### Throws

Error if the same directive appears in both "only" and "skip" lists

### Example

```typescript
const cliOptions = { only: ["@example"], skip: ["@internal"] };
const configOptions = { onlyDocDirective: ["@auth"] };

const visibilityDirectives = getVisibilityDirectives(cliOptions, configOptions);
console.log(visibilityDirectives);
// {
//   onlyDocDirective: ["example", "auth"],
//   skipDocDirective: ["internal"]
// }

// Invalid - will throw an error
getVisibilityDirectives({ only: ["@example"], skip: ["@example"] }, {}); // Error: The same directive cannot be declared in 'onlyDocDirective' and 'skipDocDirective'.
```

### See

[getOnlyDocDirectives](#getonlydocdirectives) and [getSkipDocDirectives](#getskipdocdirectives) for directive retrieval

---

## parseDeprecatedDocOptions() \{#parsedeprecateddocoptions\}

```ts
function parseDeprecatedDocOptions(
  _cliOpts,
  _configOptions,
): Record<string, never>;
```

Defined in: core/src/config.ts:459

Placeholder function for handling deprecated document options.
Currently returns an empty object as these options are deprecated.

### Parameters

#### \_cliOpts

`Maybe`&lt;`Omit`&lt;`DeprecatedCliOptions`, `"never"`&gt;&gt;

Deprecated CLI options (unused)

#### \_configOptions

`Maybe`&lt;`Omit`&lt;`DeprecatedConfigDocOptions`, `"never"`&gt;&gt;

Deprecated config options (unused)

### Returns

`Record`&lt;`string`, `never`&gt;

An empty object

---

## parseDeprecatedPrintTypeOptions() \{#parsedeprecatedprinttypeoptions\}

```ts
function parseDeprecatedPrintTypeOptions(
  cliOpts,
  configOptions,
): Record<string, never>;
```

Defined in: core/src/config.ts:593

Handles deprecated print type options.

Emits deprecation warnings when legacy section toggle options are detected
from CLI flags or config file values.

### Parameters

#### cliOpts

`Maybe`&lt;`Pick`&lt;`CliOptions`, `"noCode"` \| `"noExample"` \| `"noRelatedType"`&gt;&gt;

CLI options containing deprecated print type flags

#### configOptions

`Maybe`&lt;`Pick`&lt;`ConfigPrintTypeOptions`, `"codeSection"` \| `"exampleSection"` \| `"relatedTypeSection"`&gt;&gt;

Config options containing deprecated print type settings

### Returns

`Record`&lt;`string`, `never`&gt;

An empty object reserved for backward compatibility

---

## parseGroupByOption() \{#parsegroupbyoption\}

```ts
function parseGroupByOption(groupOptions): Maybe<GroupByDirectiveOptions>;
```

Defined in: core/src/config.ts:732

Parses and validates the groupByDirective option string format.
The format should be @directive(field|=fallback) where:

- directive: Name of the directive to group by
- field: Name of the field in the directive to use for grouping
- fallback: (Optional) Fallback group name for items without the directive

### Parameters

#### groupOptions

`unknown`

The group directive option as a string

### Returns

`Maybe`&lt;`GroupByDirectiveOptions`&gt;

A parsed `GroupByDirectiveOptions` object or `undefined` if invalid

### Throws

Error if the groupByDirective format is invalid

### Example

```typescript
// Basic usage with directive and field
const groupBy1 = parseGroupByOption("@tag(name)");
console.log(groupBy1);
// { directive: "tag", field: "name", fallback: "Miscellaneous" }

// With custom fallback group
const groupBy2 = parseGroupByOption("@category(name|=Other)");
console.log(groupBy2);
// { directive: "category", field: "name", fallback: "Other" }

// Invalid format - will throw an error
parseGroupByOption("invalid-format");
// Error: Invalid "invalid-format"
```

---

## parseHomepageOption() \{#parsehomepageoption\}

```ts
function parseHomepageOption(cliHomepage, configHomepage): Maybe<string>;
```

Defined in: core/src/config.ts:752

### Parameters

#### cliHomepage

`Maybe`&lt;`string` \| `false`&gt;

#### configHomepage

`Maybe`&lt;`string` \| `false`&gt;

### Returns

`Maybe`&lt;`string`&gt;

---

## patterns

Regular expressions and string patterns used throughout the core package.

This module centralizes all regex patterns and constants to ensure consistency
and simplify maintenance when patterns need to be updated.

## CONFIG_CONSTANTS \{#config_constants\}

```ts
const CONFIG_CONSTANTS: object;
```

Defined in: core/src/const/patterns.ts:115

String constants used for configuration parsing and defaults.

### Type Declaration

#### DEFAULT_GROUP \{#default_group\}

```ts
readonly DEFAULT_GROUP: "Miscellaneous";
```

Default fallback group name used when groupByDirective is configured.
Items without the grouping directive are assigned to this group.

---

## PATTERNS \{#patterns\}

```ts
const PATTERNS: object;
```

Defined in: core/src/const/patterns.ts:20

Central repository of regex patterns used for configuration parsing and string transformation.

### Type Declaration

#### CASE_TRANSITION \{#case_transition\}

```ts
readonly CASE_TRANSITION: RegExp;
```

Matches transitions between lowercase/digits and uppercase letters.
Used to insert spaces in camelCase strings (e.g., "userId" → "user Id").

##### Pattern

`([a-z]+|\d+)([A-Z])`

##### Example

```ts
- "userId" matches → insert space between "id" and "U" → "user Id"
- "HTTPServer" does not match (no lowercase/digit before uppercase)
- "get2Users" matches → insert space between "2" and "U" → "get 2 Users"
```

#### DIGIT_LETTER_TRANSITION \{#digit_letter_transition\}

```ts
readonly DIGIT_LETTER_TRANSITION: RegExp;
```

Matches transitions from digits to letters.
Used to insert spaces between numbers and letters (e.g., "2k" → "2 k").

##### Pattern

`(\d+)([a-z])`

##### Example

```ts
- "2k" matches → "2 k"
- "123abc" matches → "123 abc"
- "2K" does not match (K is uppercase)
```

#### DIRECTIVE_NAME \{#directive_name\}

```ts
readonly DIRECTIVE_NAME: RegExp;
```

Matches directive names with named capture groups.
Captures the directive name after the @ symbol.

##### Pattern

`^\@(?<directive>\w+)$`

##### Example

```ts
- "@tag" matches → directive: "tag"
- "@myDirective" matches → directive: "myDirective"
- "@" does not match
- "tag" does not match
```

#### GROUP_BY_DIRECTIVE \{#group_by_directive\}

```ts
readonly GROUP_BY_DIRECTIVE: RegExp;
```

Matches group-by directive format with directive name, field, and optional fallback.
Groups: (1) directive name, (2) field name, (3) optional fallback

##### Pattern

`^\@(\w+)\((\w+)(?:\|=(\w+))?\)$`

##### Example

```ts
- "@tag(name)" matches → ["@tag(name)", "tag", "name", undefined]
- "@category(type|=Other)" matches → ["@category(type|=Other)", "category", "type", "Other"]
- "@tag()" does not match
- "tag(name)" does not match
```

#### LETTER_DIGIT_TRANSITION \{#letter_digit_transition\}

```ts
readonly LETTER_DIGIT_TRANSITION: RegExp;
```

Matches transitions from letters to digits.
Used to insert spaces between letters and numbers (e.g., "user1" → "user 1").

##### Pattern

`([a-z]+)(\d)`

##### Example

```ts
- "user1" matches → "user 1"
- "abc123" matches → "abc 123"
- "U1" does not match (U is uppercase)
```

#### NUMERIC_PREFIX \{#numeric_prefix\}

```ts
readonly NUMERIC_PREFIX: RegExp;
```

Matches numeric prefix for sorted categories (e.g., "01-query" → "query").
Used to extract category names from numbered folder names.

Pattern: `^\d{2}-`

##### Example

```typescript
- "01-query" matches → remove "01-" → "query"
- "02-mutations" matches → remove "02-" → "mutations"
- "query" does not match
- "1-query" does not match (only 1 digit)
```

#### WORD_BOUNDARY \{#word_boundary\}

```ts
readonly WORD_BOUNDARY: RegExp;
```

Matches word boundaries (non-alphanumeric characters) for string splitting.
Used globally to split strings on any non-alphanumeric character.

##### Pattern

`[^0-9A-Za-z]+`

##### Example

```ts
- "hello-world" split → ["hello", "world"]
- "hello_world" split → ["hello", "world"]
- "hello world" split → ["hello", "world"]
```

### Example

```typescript

const match = PATTERNS.DIRECTIVE_NAME.exec("@myDirective");
```

---

## diff

Diff utilities for detecting schema changes between builds.

## Schema

### hasChanges() \{#haschanges\}

```ts
function hasChanges(schema, tmpDir, diffMethod, diffModule?): Promise<boolean>;
```

Defined in: core/src/diff.ts:67

Determines if there are changes in the GraphQL schema by using a specified diff method and module.

#### Parameters

##### schema

`GraphQLSchema`

The GraphQL schema to check for changes.

##### tmpDir

`string`

The temporary directory to store intermediate files during the diff process.

##### diffMethod

`Maybe`&lt;`DiffMethodName`&gt;

The name of the diff method to use. Must be a string or `null`.

##### diffModule?

`Maybe`&lt;`string`&gt; = `"@graphql-markdown/diff"`

The module to import for performing the diff. Defaults to `@graphql-markdown/diff`.

#### Returns

`Promise`&lt;`boolean`&gt;

A promise that resolves to `true` if changes are detected or if the diff method/module is invalid, otherwise `false`.

#### Examples

```typescript

const schema = buildSchema(`
  type Query {
    hello: String
  }
`);

const changesDetected = await hasChanges(schema, "/tmp", "methodName");
console.log(changesDetected); // true or false
```

```typescript

const schema = getMySchema();
const result = await hasChanges(
  schema,
  "/tmp/schema-diff",
  "breaking",
  "./my-custom-diff-module",
);
```

#### Throws

Will log a warning if the specified diff module cannot be found.

#### See

- DiffMethodName for available diff methods
- FunctionCheckSchemaChanges for the signature of the function imported from the diff module

#### Since

1.0.0

---

## normalize

Directive name normalization and processing utilities.

This module consolidates utilities for handling directive names from multiple
sources (CLI, config file, etc.) ensuring consistent normalization across
the application.

## combineDirectiveNames() \{#combinedirectivenames\}

```ts
function combineDirectiveNames(...sources): DirectiveName[];
```

Defined in: core/src/directives/normalize.ts:94

Combines and deduplicates directive names from multiple sources in one step.

This is a convenience function that combines normalizeDirectiveNames
with uniqueDirectiveNames for the common case where you need both
normalization and deduplication.

### Parameters

#### sources

...`Maybe`&lt;`DirectiveName`[]&gt;[]

Multiple arrays of directive names or undefined/null values

### Returns

`DirectiveName`[]

A single array of deduplicated directive names

### Example

```typescript

const cliDirectives = ["@example", "@internal"];
const configDirectives = ["@auth", "@example"]; // @example is duplicate

const all = combineDirectiveNames(cliDirectives, configDirectives);
// Result: ["@example", "@internal", "@auth"]
```

---

## normalizeDirectiveNames() \{#normalizedirectivenames\}

```ts
function normalizeDirectiveNames(...sources): DirectiveName[];
```

Defined in: core/src/directives/normalize.ts:42

Normalizes directive names from multiple sources into a single flattened array.

This function:

1. Accepts multiple directive name arrays from different sources
2. Filters out null/undefined values and empty arrays
3. Flattens them into a single array
4. Returns the normalized array (may contain duplicates if sources contain duplicates)

Useful when combining directives from CLI, config file, and environment sources.

### Parameters

#### sources

...`Maybe`&lt;`DirectiveName`[]&gt;[]

Multiple arrays of directive names or undefined/null values

### Returns

`DirectiveName`[]

A single array of normalized directive names (may contain duplicates)

### Example

```typescript

const cliDirectives = ["@example", "@internal"];
const configDirectives = ["@auth"];

const all = normalizeDirectiveNames(cliDirectives, configDirectives);
// Result: ["@example", "@internal", "@auth"]

// Safely handles undefined:
const safe = normalizeDirectiveNames(
  cliDirectives,
  undefined,
  configDirectives,
);
// Result: ["@example", "@internal", "@auth"]
```

---

## uniqueDirectiveNames() \{#uniquedirectivenames\}

```ts
function uniqueDirectiveNames(directives): DirectiveName[];
```

Defined in: core/src/directives/normalize.ts:67

Removes duplicate directive names from an array while preserving order.

### Parameters

#### directives

`DirectiveName`[]

Array of directive names that may contain duplicates

### Returns

`DirectiveName`[]

A new array with duplicate directive names removed

### Example

```typescript

const directives = ["@auth", "@example", "@auth", "@internal"];
const unique = uniqueDirectiveNames(directives);
// Result: ["@auth", "@example", "@internal"]
```

---

## validation

Configuration validation utilities for directive and configuration options.

Provides type guard functions and validators for checking configuration object shapes,
function types, and property existence patterns commonly used across the codebase.

## hasDescriptor() \{#hasdescriptor\}

```ts
function hasDescriptor(
  config,
): config is Record<"descriptor", (args: unknown[]) => unknown>;
```

Defined in: core/src/directives/validation.ts:39

Type guard to check if an object has a `descriptor` function property.

Validates that the object is a proper type object and contains a function named `descriptor`.

### Parameters

#### config

`unknown`

The configuration object to check

### Returns

`config is Record<"descriptor", (args: unknown[]) => unknown>`

True if config has a descriptor function property

### Example

```typescript
if (hasDescriptor(option)) {
  // option.descriptor is guaranteed to be a function
  const result = option.descriptor(directive);
}
```

---

## hasTag() \{#hastag\}

```ts
function hasTag(config): config is Record<"tag", (args: unknown[]) => unknown>;
```

Defined in: core/src/directives/validation.ts:65

Type guard to check if an object has a `tag` function property.

Validates that the object is a proper type object and contains a function named `tag`.

### Parameters

#### config

`unknown`

The configuration object to check

### Returns

`config is Record<"tag", (args: unknown[]) => unknown>`

True if config has a tag function property

### Example

```typescript
if (hasTag(option)) {
  // option.tag is guaranteed to be a function
  const result = option.tag(directive);
}
```

---

## isGroupsObject() \{#isgroupsobject\}

```ts
function isGroupsObject(groups): groups is Record<string, string>;
```

Defined in: core/src/directives/validation.ts:153

Type guard to check if a value is a configuration group object.

Validates that the value is a type object (not null, not array, not primitive).

### Parameters

#### groups

`unknown`

The groups value to check

### Returns

`groups is Record<string, string>`

True if groups is an object mapping (not an array)

### Example

```typescript
if (isGroupsObject(options.groups)) {
  // groups is an object with configuration overrides
  folderNames = { ...API_GROUPS, ...groups };
}
```

---

## isInvalidFunctionProperty() \{#isinvalidfunctionproperty\}

```ts
function isInvalidFunctionProperty(
  config,
  property,
): config is Record<string, unknown>;
```

Defined in: core/src/directives/validation.ts:196

Type guard to check if a descriptor or tag property is NOT a function.

Used for validation to detect invalid configuration where descriptor or tag
are defined but are not callable functions.

### Parameters

#### config

`unknown`

The configuration object to check

#### property

`"descriptor"` \| `"tag"`

The property name to check ("descriptor" or "tag")

### Returns

`config is Record<string, unknown>`

True if the property exists but is not a function

### Example

```typescript
if (isInvalidFunctionProperty(option, "descriptor")) {
  throw new Error("descriptor must be a function");
}
```

---

## isLoaderString() \{#isloaderstring\}

```ts
function isLoaderString(loader): loader is string;
```

Defined in: core/src/directives/validation.ts:175

Type guard to check if a value is a loader module name (string).

Validates that the value is a string representing a module name for dynamic loading.

### Parameters

#### loader

`unknown`

The loader value to check

### Returns

`loader is string`

True if loader is a string module name

### Example

```typescript
if (isLoaderString(loaders[name])) {
  // loaders[name] is a string module name that needs wrapping
  loaders[name] = { module: loaders[name], options };
}
```

---

## isPath() \{#ispath\}

```ts
function isPath(path): path is string;
```

Defined in: core/src/directives/validation.ts:133

Type guard to check if a value is a valid non-empty path string.

Validates that the value is a string and not empty, suitable for file paths or URLs.

### Parameters

#### path

`unknown`

The path value to check

### Returns

`path is string`

True if path is a non-empty string

### Example

```typescript
if (isPath(folderPath)) {
  // folderPath is guaranteed to be a non-empty string
  const fullPath = join(basePath, folderPath);
}
```

---

## isSchemaObject() \{#isschemaobject\}

```ts
function isSchemaObject(schema): schema is Record<string, unknown>;
```

Defined in: core/src/directives/validation.ts:111

Type guard to check if a value is a schema object (key-value mapping).

Validates that the value is a type object, not null, not an array, and can be treated as a schema map.

### Parameters

#### schema

`unknown`

The schema value to check

### Returns

`schema is Record<string, unknown>`

True if schema is an object mapping (not an array)

### Example

```typescript
if (isSchemaObject(projectConfig.schema)) {
  // Extract first key from schema map
  const key = Object.keys(schema)[0];
}
```

---

## isSchemaString() \{#isschemastring\}

```ts
function isSchemaString(schema): schema is string;
```

Defined in: core/src/directives/validation.ts:91

Type guard to check if a value is a schema string.

Validates that the value is a string representing a GraphQL schema path or URL.

### Parameters

#### schema

`unknown`

The schema value to check

### Returns

`schema is string`

True if schema is a string

### Example

```typescript
if (isSchemaString(config.schema)) {
  // config.schema is a string path/URL
  const schemaUrl = config.schema;
}
```

---

## event-emitter

## Events

### EmitResult \{#emitresult\}

Defined in: core/src/event-emitter.ts:9

Result object returned when emitting a cancellable event.

#### Properties

##### defaultPrevented \{#defaultprevented\}

```ts
defaultPrevented: boolean;
```

Defined in: core/src/event-emitter.ts:20

Whether any handler called preventDefault() on the event.
Only applicable if the event is cancellable.

##### errors \{#errors\}

```ts
errors: Error[];
```

Defined in: core/src/event-emitter.ts:14

Array of errors that occurred during handler execution.
Handlers continue executing even if previous handlers throw errors.

---

### getEvents() \{#getevents\}

```ts
function getEvents(): CancellableEventEmitter;
```

Defined in: core/src/event-emitter.ts:172

Get the singleton event emitter instance.

Creates the instance on first call, then returns the same instance on subsequent calls.
This ensures all parts of the application share the same event bus.

#### Returns

`CancellableEventEmitter`

The singleton CancellableEventEmitter instance

#### Example

```typescript
// In generator.ts
const events = getEvents();
events.on("beforeLoadSchema", handler);

// In renderer.ts - same instance!
const events = getEvents();
await events.emitAsync("beforeLoadSchema", event);
```

---

### resetEvents() \{#resetevents\}

```ts
function resetEvents(): void;
```

Defined in: core/src/event-emitter.ts:196

Reset the event emitter singleton.

Removes all event listeners and clears the instance.
The next call to getEvents() will create a fresh instance.

**Important:** This should only be used in tests to ensure test isolation.

#### Returns

`void`

#### Example

```typescript
// In test setup
afterEach(() => {
  resetEvents();
  jest.restoreAllMocks();
});
```

---

## event-handlers

MDX event handler registration functionality.

This module provides utilities for registering MDX module event handlers
with the event emitter system. It maps event names to callback names and
automatically detects and registers matching callbacks from MDX modules.

## registerMDXEventHandlers() \{#registermdxeventhandlers\}

```ts
function registerMDXEventHandlers(mdxModule): void;
```

Defined in: core/src/event-handlers.ts:35

Registers MDX module lifecycle event handlers with the event emitter.

Automatically detects and registers any lifecycle hook functions defined in the mdxModule
that match the event callback naming convention. Logs registered handlers at debug level.

Note: Format functions (formatMDXBadge, etc.) are NOT registered as events.
They are pure transformations handled via the Formatter interface directly.

### Parameters

#### mdxModule

`unknown`

The MDX module that may contain event callback functions

### Returns

`void`

### Example

```typescript
const mdxModule = {
  beforeLoadSchemaHook: async (event) => {
    console.log("Loading schema...");
  },
  afterRenderTypeEntitiesHook: async (event) => {
    console.log("Rendered:", event.data.name);
  },
};
registerMDXEventHandlers(mdxModule);
```

---

## event-map

Event callback mapping configuration.

This module defines the mappings between event names and their corresponding
callback names in MDX modules. Kept separate to avoid circular dependencies.

## EVENT_CALLBACK_MAP \{#event_callback_map\}

```ts
const EVENT_CALLBACK_MAP: object;
```

Defined in: core/src/event-map.ts:24

Event callback mapping configuration.
Maps event names to their corresponding callback names in mdxModule.

Note: Format functions (formatMDXBadge, formatMDXAdmonition, etc.) are NOT included here.
They are pure transformations handled via the Formatter interface, not events.

### Type Declaration

#### diff:afterCheck \{#diffaftercheck\}

```ts
readonly diff:afterCheck: "afterCheckDiffHook" = "afterCheckDiffHook";
```

#### diff:beforeCheck \{#diffbeforecheck\}

```ts
readonly diff:beforeCheck: "beforeCheckDiffHook" = "beforeCheckDiffHook";
```

#### print:afterPrintCode \{#printafterprintcode\}

```ts
readonly print:afterPrintCode: "afterPrintCodeHook" = "afterPrintCodeHook";
```

#### print:afterPrintType \{#printafterprinttype\}

```ts
readonly print:afterPrintType: "afterPrintTypeHook" = "afterPrintTypeHook";
```

#### print:beforeComposePageType \{#printbeforecomposepagetype\}

```ts
readonly print:beforeComposePageType: "beforeComposePageTypeHook" = "beforeComposePageTypeHook";
```

#### print:beforePrintCode \{#printbeforeprintcode\}

```ts
readonly print:beforePrintCode: "beforePrintCodeHook" = "beforePrintCodeHook";
```

#### print:beforePrintType \{#printbeforeprinttype\}

```ts
readonly print:beforePrintType: "beforePrintTypeHook" = "beforePrintTypeHook";
```

#### render:afterGenerateIndexMetafile \{#renderaftergenerateindexmetafile\}

```ts
readonly render:afterGenerateIndexMetafile: "afterGenerateIndexMetafileHook" = "afterGenerateIndexMetafileHook";
```

#### render:afterRenderHomepage \{#renderafterrenderhomepage\}

```ts
readonly render:afterRenderHomepage: "afterRenderHomepageHook" = "afterRenderHomepageHook";
```

#### render:afterRenderRootTypes \{#renderafterrenderroottypes\}

```ts
readonly render:afterRenderRootTypes: "afterRenderRootTypesHook" = "afterRenderRootTypesHook";
```

#### render:afterRenderTypeEntities \{#renderafterrendertypeentities\}

```ts
readonly render:afterRenderTypeEntities: "afterRenderTypeEntitiesHook" = "afterRenderTypeEntitiesHook";
```

#### render:beforeGenerateIndexMetafile \{#renderbeforegenerateindexmetafile\}

```ts
readonly render:beforeGenerateIndexMetafile: "beforeGenerateIndexMetafileHook" = "beforeGenerateIndexMetafileHook";
```

#### render:beforeRenderHomepage \{#renderbeforerenderhomepage\}

```ts
readonly render:beforeRenderHomepage: "beforeRenderHomepageHook" = "beforeRenderHomepageHook";
```

#### render:beforeRenderRootTypes \{#renderbeforerenderroottypes\}

```ts
readonly render:beforeRenderRootTypes: "beforeRenderRootTypesHook" = "beforeRenderRootTypesHook";
```

#### render:beforeRenderTypeEntities \{#renderbeforerendertypeentities\}

```ts
readonly render:beforeRenderTypeEntities: "beforeRenderTypeEntitiesHook" = "beforeRenderTypeEntitiesHook";
```

#### schema:afterLoad \{#schemaafterload\}

```ts
readonly schema:afterLoad: "afterLoadSchemaHook" = "afterLoadSchemaHook";
```

#### schema:beforeLoad \{#schemabeforeload\}

```ts
readonly schema:beforeLoad: "beforeLoadSchemaHook" = "beforeLoadSchemaHook";
```

---

## diff-check

Diff checking event class.

## Events

### DiffCheckEvent \{#diffcheckevent\}

Defined in: core/src/events/diff-check.ts:15

Event emitted before/after checking schema differences.

#### Extends

- [`DataEvent`](../../utils/events.md#abstract-dataevent)&lt;\{
  `outputDir?`: `string`;
  `schema?`: `unknown`;
  `schemaHasChanges?`: `boolean`;
  \}&gt;

#### Constructors

##### Constructor

```ts
new DiffCheckEvent(data, options?): DiffCheckEvent;
```

Defined in: core/src/events/diff-check.ts:20

###### Parameters

###### data

###### outputDir?

`string`

###### schema?

`unknown`

###### schemaHasChanges?

`boolean`

###### options?

[`CancellableEventOptions`](../../utils/events.md#cancellableeventoptions)

###### Returns

[`DiffCheckEvent`](#diffcheckevent)

###### Overrides

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`constructor`](../../utils/events.md#constructor-1)

#### Properties

##### data \{#data\}

```ts
readonly data: object;
```

Defined in: utils/dist/events.d.ts:111

Read-only event data payload.

###### outputDir?

```ts
optional outputDir?: string;
```

###### schema?

```ts
optional schema?: unknown;
```

###### schemaHasChanges?

```ts
optional schemaHasChanges?: boolean;
```

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`data`](../../utils/events.md#data)

#### Accessors

##### defaultAction \{#defaultaction\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: utils/dist/events.d.ts:78

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultAction`](../../utils/events.md#defaultaction-1)

##### defaultPrevented \{#defaultprevented\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: utils/dist/events.d.ts:70

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: utils/dist/events.d.ts:82

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultPrevented`](../../utils/events.md#defaultprevented-1)

##### propagationStopped \{#propagationstopped\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: utils/dist/events.d.ts:74

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: utils/dist/events.d.ts:86

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`propagationStopped`](../../utils/events.md#propagationstopped-1)

#### Methods

##### preventDefault() \{#preventdefault\}

```ts
preventDefault(): void;
```

Defined in: utils/dist/events.d.ts:91

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`preventDefault`](../../utils/events.md#preventdefault-1)

##### runDefaultAction() \{#rundefaultaction\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: utils/dist/events.d.ts:100

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`runDefaultAction`](../../utils/events.md#rundefaultaction-1)

##### stopPropagation() \{#stoppropagation\}

```ts
stopPropagation(): void;
```

Defined in: utils/dist/events.d.ts:96

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`stopPropagation`](../../utils/events.md#stoppropagation-1)

---

## diff-events

Diff checking event constants.

## DiffEvents \{#diffevents\}

```ts
const DiffEvents: object;
```

Defined in: core/src/events/diff-events.ts:10

Event names for diff checking lifecycle.

### Type Declaration

#### AFTER_CHECK \{#after_check\}

```ts
readonly AFTER_CHECK: "diff:afterCheck" = "diff:afterCheck";
```

Emitted after checking schema differences

#### BEFORE_CHECK \{#before_check\}

```ts
readonly BEFORE_CHECK: "diff:beforeCheck" = "diff:beforeCheck";
```

Emitted before checking schema differences

---

## generate-index-metafile-events

Generate index metafile event constants.

## GenerateIndexMetafileEvents \{#generateindexmetafileevents\}

```ts
const GenerateIndexMetafileEvents: object;
```

Defined in: core/src/events/generate-index-metafile-events.ts:10

Event names for generating index metafile.

### Type Declaration

#### AFTER_GENERATE \{#after_generate\}

```ts
readonly AFTER_GENERATE: "render:afterGenerateIndexMetafile" = "render:afterGenerateIndexMetafile";
```

Emitted after generating index metafile

#### BEFORE_GENERATE \{#before_generate\}

```ts
readonly BEFORE_GENERATE: "render:beforeGenerateIndexMetafile" = "render:beforeGenerateIndexMetafile";
```

Emitted before generating index metafile

---

## generate-index-metafile

Generate index metafile event class.

## Events

### GenerateIndexMetafileEvent \{#generateindexmetafileevent\}

Defined in: core/src/events/generate-index-metafile.ts:15

Event emitted before/after generating index metafile.

#### Extends

- [`DataEvent`](../../utils/events.md#abstract-dataevent)&lt;\{
  `category`: `string`;
  `dirPath`: `string`;
  `options?`: `Record`&lt;`string`, `unknown`&gt;;
  \}&gt;

#### Constructors

##### Constructor

```ts
new GenerateIndexMetafileEvent(data, options?): GenerateIndexMetafileEvent;
```

Defined in: core/src/events/generate-index-metafile.ts:20

###### Parameters

###### data

###### category

`string`

###### dirPath

`string`

###### options?

`Record`&lt;`string`, `unknown`&gt;

###### options?

[`CancellableEventOptions`](../../utils/events.md#cancellableeventoptions)

###### Returns

[`GenerateIndexMetafileEvent`](#generateindexmetafileevent)

###### Overrides

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`constructor`](../../utils/events.md#constructor-1)

#### Properties

##### data \{#data\}

```ts
readonly data: object;
```

Defined in: utils/dist/events.d.ts:111

Read-only event data payload.

###### category

```ts
category: string;
```

###### dirPath

```ts
dirPath: string;
```

###### options?

```ts
optional options?: Record<string, unknown>;
```

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`data`](../../utils/events.md#data)

#### Accessors

##### defaultAction \{#defaultaction\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: utils/dist/events.d.ts:78

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultAction`](../../utils/events.md#defaultaction-1)

##### defaultPrevented \{#defaultprevented\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: utils/dist/events.d.ts:70

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: utils/dist/events.d.ts:82

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultPrevented`](../../utils/events.md#defaultprevented-1)

##### propagationStopped \{#propagationstopped\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: utils/dist/events.d.ts:74

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: utils/dist/events.d.ts:86

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`propagationStopped`](../../utils/events.md#propagationstopped-1)

#### Methods

##### preventDefault() \{#preventdefault\}

```ts
preventDefault(): void;
```

Defined in: utils/dist/events.d.ts:91

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`preventDefault`](../../utils/events.md#preventdefault-1)

##### runDefaultAction() \{#rundefaultaction\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: utils/dist/events.d.ts:100

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`runDefaultAction`](../../utils/events.md#rundefaultaction-1)

##### stopPropagation() \{#stoppropagation\}

```ts
stopPropagation(): void;
```

Defined in: utils/dist/events.d.ts:96

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`stopPropagation`](../../utils/events.md#stoppropagation-1)

---

## print-type-events

Print type event constants.

Events emitted during the printing phase of type documentation generation.
These events allow interception and modification of the generated code output.

## PrintTypeEvents \{#printtypeevents\}

```ts
const PrintTypeEvents: object;
```

Defined in: core/src/events/print-type-events.ts:25

Event names for printing type documentation.

### Type Declaration

#### AFTER_PRINT_CODE \{#after_print_code\}

```ts
readonly AFTER_PRINT_CODE: "print:afterPrintCode" = "print:afterPrintCode";
```

Emitted after generating the code block for a type (output can be modified)

#### AFTER_PRINT_TYPE \{#after_print_type\}

```ts
readonly AFTER_PRINT_TYPE: "print:afterPrintType" = "print:afterPrintType";
```

Emitted after generating the full type documentation (output can be modified)

#### BEFORE_COMPOSE_PAGE_TYPE \{#before_compose_page_type\}

```ts
readonly BEFORE_COMPOSE_PAGE_TYPE: "print:beforeComposePageType" = "print:beforeComposePageType";
```

Emitted before composing page sections (can modify section content)

#### BEFORE_PRINT_CODE \{#before_print_code\}

```ts
readonly BEFORE_PRINT_CODE: "print:beforePrintCode" = "print:beforePrintCode";
```

Emitted before generating the code block for a type

#### BEFORE_PRINT_TYPE \{#before_print_type\}

```ts
readonly BEFORE_PRINT_TYPE: "print:beforePrintType" = "print:beforePrintType";
```

Emitted before generating the full type documentation

### Example

```typescript

const events = getEvents();
events.on(PrintTypeEvents.AFTER_PRINT_CODE, (event: PrintCodeEvent) => {
  // Modify the generated code
  event.output = event.output.toUpperCase();
});
```

---

## print-type

Print type interfaces — re-exported from @graphql-markdown/types.

Event class implementations (PrintCodeEvent, PrintTypeEvent, etc.) live in
@graphql-markdown/printer-legacy, which is the package that emits the events.

---

## render-homepage-events

Render homepage event constants.

## RenderHomepageEvents \{#renderhomepageevents\}

```ts
const RenderHomepageEvents: object;
```

Defined in: core/src/events/render-homepage-events.ts:10

Event names for rendering homepage.

### Type Declaration

#### AFTER_RENDER \{#after_render\}

```ts
readonly AFTER_RENDER: "render:afterRenderHomepage" = "render:afterRenderHomepage";
```

Emitted after rendering homepage

#### BEFORE_RENDER \{#before_render\}

```ts
readonly BEFORE_RENDER: "render:beforeRenderHomepage" = "render:beforeRenderHomepage";
```

Emitted before rendering homepage

---

## render-homepage

Render homepage event class.

## Events

### RenderHomepageEvent \{#renderhomepageevent\}

Defined in: core/src/events/render-homepage.ts:15

Event emitted before/after rendering homepage.

#### Extends

- [`DataEvent`](../../utils/events.md#abstract-dataevent)&lt;\{
  `outputDir`: `string`;
  \}&gt;

#### Constructors

##### Constructor

```ts
new RenderHomepageEvent(data, options?): RenderHomepageEvent;
```

Defined in: core/src/events/render-homepage.ts:18

###### Parameters

###### data

###### outputDir

`string`

###### options?

[`CancellableEventOptions`](../../utils/events.md#cancellableeventoptions)

###### Returns

[`RenderHomepageEvent`](#renderhomepageevent)

###### Overrides

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`constructor`](../../utils/events.md#constructor-1)

#### Properties

##### data \{#data\}

```ts
readonly data: object;
```

Defined in: utils/dist/events.d.ts:111

Read-only event data payload.

###### outputDir

```ts
outputDir: string;
```

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`data`](../../utils/events.md#data)

#### Accessors

##### defaultAction \{#defaultaction\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: utils/dist/events.d.ts:78

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultAction`](../../utils/events.md#defaultaction-1)

##### defaultPrevented \{#defaultprevented\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: utils/dist/events.d.ts:70

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: utils/dist/events.d.ts:82

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultPrevented`](../../utils/events.md#defaultprevented-1)

##### propagationStopped \{#propagationstopped\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: utils/dist/events.d.ts:74

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: utils/dist/events.d.ts:86

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`propagationStopped`](../../utils/events.md#propagationstopped-1)

#### Methods

##### preventDefault() \{#preventdefault\}

```ts
preventDefault(): void;
```

Defined in: utils/dist/events.d.ts:91

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`preventDefault`](../../utils/events.md#preventdefault-1)

##### runDefaultAction() \{#rundefaultaction\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: utils/dist/events.d.ts:100

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`runDefaultAction`](../../utils/events.md#rundefaultaction-1)

##### stopPropagation() \{#stoppropagation\}

```ts
stopPropagation(): void;
```

Defined in: utils/dist/events.d.ts:96

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`stopPropagation`](../../utils/events.md#stoppropagation-1)

---

## render-root-types-events

Render root types event constants.

## RenderRootTypesEvents \{#renderroottypesevents\}

```ts
const RenderRootTypesEvents: object;
```

Defined in: core/src/events/render-root-types-events.ts:10

Event names for rendering root types.

### Type Declaration

#### AFTER_RENDER \{#after_render\}

```ts
readonly AFTER_RENDER: "render:afterRenderRootTypes" = "render:afterRenderRootTypes";
```

Emitted after rendering root types

#### BEFORE_RENDER \{#before_render\}

```ts
readonly BEFORE_RENDER: "render:beforeRenderRootTypes" = "render:beforeRenderRootTypes";
```

Emitted before rendering root types

---

## render-root-types

Render root types event class.

## Events

### RenderRootTypesEvent \{#renderroottypesevent\}

Defined in: core/src/events/render-root-types.ts:15

Event emitted before/after rendering root types.

#### Extends

- [`DataEvent`](../../utils/events.md#abstract-dataevent)&lt;\{
  `rootTypes`: `unknown`;
  \}&gt;

#### Constructors

##### Constructor

```ts
new RenderRootTypesEvent(data, options?): RenderRootTypesEvent;
```

Defined in: core/src/events/render-root-types.ts:18

###### Parameters

###### data

###### rootTypes

`unknown`

###### options?

[`CancellableEventOptions`](../../utils/events.md#cancellableeventoptions)

###### Returns

[`RenderRootTypesEvent`](#renderroottypesevent)

###### Overrides

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`constructor`](../../utils/events.md#constructor-1)

#### Properties

##### data \{#data\}

```ts
readonly data: object;
```

Defined in: utils/dist/events.d.ts:111

Read-only event data payload.

###### rootTypes

```ts
rootTypes: unknown;
```

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`data`](../../utils/events.md#data)

#### Accessors

##### defaultAction \{#defaultaction\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: utils/dist/events.d.ts:78

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultAction`](../../utils/events.md#defaultaction-1)

##### defaultPrevented \{#defaultprevented\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: utils/dist/events.d.ts:70

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: utils/dist/events.d.ts:82

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultPrevented`](../../utils/events.md#defaultprevented-1)

##### propagationStopped \{#propagationstopped\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: utils/dist/events.d.ts:74

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: utils/dist/events.d.ts:86

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`propagationStopped`](../../utils/events.md#propagationstopped-1)

#### Methods

##### preventDefault() \{#preventdefault\}

```ts
preventDefault(): void;
```

Defined in: utils/dist/events.d.ts:91

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`preventDefault`](../../utils/events.md#preventdefault-1)

##### runDefaultAction() \{#rundefaultaction\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: utils/dist/events.d.ts:100

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`runDefaultAction`](../../utils/events.md#rundefaultaction-1)

##### stopPropagation() \{#stoppropagation\}

```ts
stopPropagation(): void;
```

Defined in: utils/dist/events.d.ts:96

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`stopPropagation`](../../utils/events.md#stoppropagation-1)

---

## render-type-entities-events

Render type entities event constants.

## RenderTypeEntitiesEvents \{#rendertypeentitiesevents\}

```ts
const RenderTypeEntitiesEvents: object;
```

Defined in: core/src/events/render-type-entities-events.ts:10

Event names for rendering type entities.

### Type Declaration

#### AFTER_RENDER \{#after_render\}

```ts
readonly AFTER_RENDER: "render:afterRenderTypeEntities" = "render:afterRenderTypeEntities";
```

Emitted after rendering type entities

#### BEFORE_RENDER \{#before_render\}

```ts
readonly BEFORE_RENDER: "render:beforeRenderTypeEntities" = "render:beforeRenderTypeEntities";
```

Emitted before rendering type entities

---

## render-type-entities

Render type entities event class.

## Events

### RenderTypeEntitiesEvent \{#rendertypeentitiesevent\}

Defined in: core/src/events/render-type-entities.ts:15

Event emitted before/after rendering type entities.

#### Extends

- [`DataEvent`](../../utils/events.md#abstract-dataevent)&lt;\{
  `filePath`: `string`;
  `name`: `string`;
  \}&gt;

#### Constructors

##### Constructor

```ts
new RenderTypeEntitiesEvent(data, options?): RenderTypeEntitiesEvent;
```

Defined in: core/src/events/render-type-entities.ts:19

###### Parameters

###### data

###### filePath

`string`

###### name

`string`

###### options?

[`CancellableEventOptions`](../../utils/events.md#cancellableeventoptions)

###### Returns

[`RenderTypeEntitiesEvent`](#rendertypeentitiesevent)

###### Overrides

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`constructor`](../../utils/events.md#constructor-1)

#### Properties

##### data \{#data\}

```ts
readonly data: object;
```

Defined in: utils/dist/events.d.ts:111

Read-only event data payload.

###### filePath

```ts
filePath: string;
```

###### name

```ts
name: string;
```

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`data`](../../utils/events.md#data)

#### Accessors

##### defaultAction \{#defaultaction\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: utils/dist/events.d.ts:78

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultAction`](../../utils/events.md#defaultaction-1)

##### defaultPrevented \{#defaultprevented\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: utils/dist/events.d.ts:70

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: utils/dist/events.d.ts:82

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultPrevented`](../../utils/events.md#defaultprevented-1)

##### propagationStopped \{#propagationstopped\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: utils/dist/events.d.ts:74

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: utils/dist/events.d.ts:86

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`propagationStopped`](../../utils/events.md#propagationstopped-1)

#### Methods

##### preventDefault() \{#preventdefault\}

```ts
preventDefault(): void;
```

Defined in: utils/dist/events.d.ts:91

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`preventDefault`](../../utils/events.md#preventdefault-1)

##### runDefaultAction() \{#rundefaultaction\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: utils/dist/events.d.ts:100

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`runDefaultAction`](../../utils/events.md#rundefaultaction-1)

##### stopPropagation() \{#stoppropagation\}

```ts
stopPropagation(): void;
```

Defined in: utils/dist/events.d.ts:96

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`stopPropagation`](../../utils/events.md#stoppropagation-1)

---

## schema-events

Schema loading event constants.

## SchemaEvents \{#schemaevents\}

```ts
const SchemaEvents: object;
```

Defined in: core/src/events/schema-events.ts:10

Event names for schema loading lifecycle.

### Type Declaration

#### AFTER_LOAD \{#after_load\}

```ts
readonly AFTER_LOAD: "schema:afterLoad" = "schema:afterLoad";
```

Emitted after loading GraphQL schema

#### AFTER_MAP \{#after_map\}

```ts
readonly AFTER_MAP: "schema:afterMap" = "schema:afterMap";
```

Emitted after mapping GraphQL schema

#### BEFORE_LOAD \{#before_load\}

```ts
readonly BEFORE_LOAD: "schema:beforeLoad" = "schema:beforeLoad";
```

Emitted before loading GraphQL schema

#### BEFORE_MAP \{#before_map\}

```ts
readonly BEFORE_MAP: "schema:beforeMap" = "schema:beforeMap";
```

Emitted before mapping GraphQL schema

---

## schema-load

Schema loading event class.

## Events

### SchemaEvent \{#schemaevent\}

Defined in: core/src/events/schema-load.ts:16

Event emitted before/after loading a GraphQL schema.

#### Extends

- [`DataEvent`](../../utils/events.md#abstract-dataevent)&lt;\{
  `rootTypes?`: `Maybe`&lt;`SchemaMap`&gt;;
  `schema?`: `Maybe`&lt;`GraphQLSchema`&gt;;
  `schemaLocation?`: `string`;
  \}&gt;

#### Constructors

##### Constructor

```ts
new SchemaEvent(data, options?): SchemaEvent;
```

Defined in: core/src/events/schema-load.ts:21

###### Parameters

###### data

###### rootTypes?

`Maybe`&lt;`SchemaMap`&gt;

###### schema?

`Maybe`&lt;`GraphQLSchema`&gt;

###### schemaLocation?

`string`

###### options?

[`CancellableEventOptions`](../../utils/events.md#cancellableeventoptions)

###### Returns

[`SchemaEvent`](#schemaevent)

###### Overrides

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`constructor`](../../utils/events.md#constructor-1)

#### Properties

##### data \{#data\}

```ts
readonly data: object;
```

Defined in: utils/dist/events.d.ts:111

Read-only event data payload.

###### rootTypes?

```ts
optional rootTypes?: Maybe<SchemaMap>;
```

###### schema?

```ts
optional schema?: Maybe<GraphQLSchema>;
```

###### schemaLocation?

```ts
optional schemaLocation?: string;
```

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`data`](../../utils/events.md#data)

#### Accessors

##### defaultAction \{#defaultaction\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: utils/dist/events.d.ts:78

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultAction`](../../utils/events.md#defaultaction-1)

##### defaultPrevented \{#defaultprevented\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: utils/dist/events.d.ts:70

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: utils/dist/events.d.ts:82

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`defaultPrevented`](../../utils/events.md#defaultprevented-1)

##### propagationStopped \{#propagationstopped\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: utils/dist/events.d.ts:74

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: utils/dist/events.d.ts:86

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`propagationStopped`](../../utils/events.md#propagationstopped-1)

#### Methods

##### preventDefault() \{#preventdefault\}

```ts
preventDefault(): void;
```

Defined in: utils/dist/events.d.ts:91

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`preventDefault`](../../utils/events.md#preventdefault-1)

##### runDefaultAction() \{#rundefaultaction\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: utils/dist/events.d.ts:100

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`runDefaultAction`](../../utils/events.md#rundefaultaction-1)

##### stopPropagation() \{#stoppropagation\}

```ts
stopPropagation(): void;
```

Defined in: utils/dist/events.d.ts:96

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Inherited from

[`DataEvent`](../../utils/events.md#abstract-dataevent).[`stopPropagation`](../../utils/events.md#stoppropagation-1)

---

## events

Event system for GraphQL-Markdown.

## ComposePageTypeEventData \{#composepagetypeeventdata\}

Defined in: types/src/printer.d.ts:114

Data payload for compose page type events.

### Properties

#### name \{#name\}

```ts
readonly name: Maybe<string>;
```

Defined in: types/src/printer.d.ts:118

The name identifier for the type

#### options \{#options\}

```ts
readonly options: PrintTypeOptions;
```

Defined in: types/src/printer.d.ts:120

The print options in effect

#### sections \{#sections\}

```ts
readonly sections: PageSections;
```

Defined in: types/src/printer.d.ts:122

The map of all page sections (mutable in BEFORE event)

#### type \{#type\}

```ts
readonly type: unknown;
```

Defined in: types/src/printer.d.ts:116

The GraphQL type being composed

---

## PageSection \{#pagesection\}

Defined in: types/src/printer.d.ts:24

Represents a single section of a page with optional title and content.

### Properties

#### content? \{#content\}

```ts
optional content?:
  | string
  | MDXString
  | PageSection
  | PageSection[];
```

Defined in: types/src/printer.d.ts:30

The section content

#### level? \{#level\}

```ts
optional level?: number;
```

Defined in: types/src/printer.d.ts:28

Optional section level for hierarchical structuring

#### title? \{#title\}

```ts
optional title?: string | MDXString;
```

Defined in: types/src/printer.d.ts:26

Optional title/heading for the section

---

## PageSections \{#pagesections\}

Defined in: types/src/printer.d.ts:36

Map of all available sections in a type page.

### Indexable

```ts
[key: string]: Maybe<PageHeader | PageSection>
```

Additional custom sections can be added by event handlers

### Properties

#### code? \{#code\}

```ts
optional code?: PageSection;
```

Defined in: types/src/printer.d.ts:50

GraphQL code block

#### customDirectives? \{#customdirectives\}

```ts
optional customDirectives?: PageSection;
```

Defined in: types/src/printer.d.ts:52

Custom directives

#### description? \{#description\}

```ts
optional description?: PageSection;
```

Defined in: types/src/printer.d.ts:48

Type description from GraphQL comments

#### example? \{#example\}

```ts
optional example?: PageSection;
```

Defined in: types/src/printer.d.ts:56

Usage examples

#### header? \{#header\}

```ts
optional header?: PageHeader;
```

Defined in: types/src/printer.d.ts:40

YAML frontmatter or top-level heading

#### mdxDeclaration? \{#mdxdeclaration\}

```ts
optional mdxDeclaration?: PageHeader;
```

Defined in: types/src/printer.d.ts:44

MDX import declarations

#### metadata? \{#metadata\}

```ts
optional metadata?: PageSection;
```

Defined in: types/src/printer.d.ts:54

Type metadata (fields, arguments, etc.)

#### metatags? \{#metatags\}

```ts
optional metatags?: PageHeader;
```

Defined in: types/src/printer.d.ts:42

HTML meta tags

#### relations? \{#relations\}

```ts
optional relations?: PageSection;
```

Defined in: types/src/printer.d.ts:58

Related types

#### tags? \{#tags\}

```ts
optional tags?: PageSection;
```

Defined in: types/src/printer.d.ts:46

Custom tags (e.g., @deprecated)

---

## PrintCodeEventData \{#printcodeeventdata\}

Defined in: types/src/printer.d.ts:64

Data payload for print code events.

### Properties

#### options \{#options-1\}

```ts
readonly options: PrintTypeOptions;
```

Defined in: types/src/printer.d.ts:70

The print options in effect

#### type \{#type-1\}

```ts
readonly type: unknown;
```

Defined in: types/src/printer.d.ts:66

The GraphQL type being printed

#### typeName \{#typename\}

```ts
readonly typeName: string;
```

Defined in: types/src/printer.d.ts:68

The name of the type

---

## PrintTypeEventData \{#printtypeeventdata\}

Defined in: types/src/printer.d.ts:76

Data payload for print type events.

### Properties

#### name \{#name-1\}

```ts
readonly name: Maybe<string>;
```

Defined in: types/src/printer.d.ts:80

The name identifier for the type

#### options \{#options-2\}

```ts
readonly options: PrintTypeOptions;
```

Defined in: types/src/printer.d.ts:82

The print options in effect

#### type \{#type-2\}

```ts
readonly type: unknown;
```

Defined in: types/src/printer.d.ts:78

The GraphQL type being printed

---

## generator

Core generator functionality for GraphQL Markdown documentation.

This module contains the main functionality for generating markdown documentation
from GraphQL schemas. It handles schema loading, processing, and markdown generation
through appropriate printers and renderers.

## FILE_EXTENSION \{#file_extension\}

```ts
const FILE_EXTENSION: object;
```

Defined in: core/src/generator.ts:62

Supported file extensions for generated documentation files.

### Type Declaration

#### MD \{#md\}

```ts
readonly MD: ".md" = ".md";
```

#### MDX \{#mdx\}

```ts
readonly MDX: ".mdx" = ".mdx";
```

### Remarks

- MDX: MDX file extension (.mdx) for React component-enabled markdown
- MD: Standard markdown file extension (.md)

---

## checkSchemaDifferences() \{#checkschemadifferences\}

```ts
function checkSchemaDifferences(
  schema,
  schemaLocation,
  diffMethod,
  tmpDir,
): Promise<boolean>;
```

Defined in: core/src/generator.ts:264

Checks if there are differences in the GraphQL schema compared to a previous version.

### Parameters

#### schema

`GraphQLSchema`

The GraphQL schema to check for differences.

#### schemaLocation

`string`

The location/path of the schema file for logging purposes.

#### diffMethod

`Maybe`&lt;`TypeDiffMethod`&gt;

The method to use for detecting differences. If set to `NONE`, changes detection is skipped.

#### tmpDir

`string`

The temporary directory path used for storing and comparing schema versions.

### Returns

`Promise`&lt;`boolean`&gt;

A promise that resolves to `true` if changes are detected or if diff method is `NONE`,
or `false` if no changes are detected.

### Remarks

When no changes are detected, a log message is generated indicating that the schema is unchanged.

---

## generateDocFromSchema() \{#generatedocfromschema\}

```ts
function generateDocFromSchema(options): Promise<void>;
```

Defined in: core/src/generator.ts:336

Main entry point for generating Markdown documentation from a GraphQL schema.

This function coordinates the entire documentation generation process:

- Loads and validates the schema
- Checks for schema changes if diffing is enabled
- Processes directives and groups
- Initializes printers and renderers
- Generates markdown files

### Parameters

#### options

`GeneratorOptions`

Complete configuration for the documentation generation

### Returns

`Promise`&lt;`void`&gt;

Promise that resolves when documentation is fully generated

---

## getFormatterFromMDXModule() \{#getformatterfrommdxmodule\}

```ts
function getFormatterFromMDXModule(
  mdxModule,
  meta?,
): Partial<Formatter> | undefined;
```

Defined in: core/src/generator.ts:169

**`Internal`**

Extracts a formatter from an MDX module.

Checks for formatter functions in the following order:

1. A `createMDXFormatter` factory function (for internal/advanced usage)
2. Individual exported formatter functions (e.g., `formatMDXBadge`, `formatMDXAdmonition`)

### Parameters

#### mdxModule

`unknown`

The loaded MDX module that may contain formatter exports

#### meta?

`MetaInfo`

Optional metadata to pass to the formatter factory

### Returns

`Partial`&lt;`Formatter`&gt; \| `undefined`

A partial Formatter with the found functions, or undefined if none found

---

## getMDXModuleProperty() \{#getmdxmoduleproperty\}

```ts
function getMDXModuleProperty<T>(mdxModule, propertyName): T | undefined;
```

Defined in: core/src/generator.ts:132

**`Internal`**

Gets a property from an MDX module, checking both the module directly and `module.default`.

This handles the differences between ESM and CommonJS module exports when dynamically importing.

### Type Parameters

#### T

`T`

### Parameters

#### mdxModule

`unknown`

The loaded MDX module

#### propertyName

`string`

The name of the property to extract

### Returns

`T` \| `undefined`

The property value if found, otherwise undefined

---

## loadGraphqlSchema() \{#loadgraphqlschema\}

```ts
function loadGraphqlSchema(
  schemaLocation,
  loadersList,
): Promise<Maybe<GraphQLSchema>>;
```

Defined in: core/src/generator.ts:233

**`Internal`**

Loads a GraphQL schema from the specified location using configured document loaders.

### Parameters

#### schemaLocation

`string`

The location/path of the GraphQL schema to load (e.g., file path, URL, or glob pattern).

#### loadersList

`Maybe`&lt;`LoaderOption`&gt;

Optional loader configuration for customizing how the schema is loaded.

### Returns

`Promise`&lt;`Maybe`&lt;`GraphQLSchema`&gt;&gt;

A promise that resolves to the loaded GraphQL schema, or undefined if:

- The loaders cannot be initialized
- An error occurs during schema loading

---

## loadMDXModule() \{#loadmdxmodule\}

```ts
function loadMDXModule(mdxParser): Promise<unknown>;
```

Defined in: core/src/generator.ts:91

**`Internal`**

Asynchronously loads an MDX module dynamically.

### Parameters

#### mdxParser

`Maybe`&lt;`string` \| `PackageName`&gt;

The MDX parser package name or path to import. Can be null or undefined.

### Returns

`Promise`&lt;`unknown`&gt;

A promise that resolves to the imported module, or undefined if:

- The mdxParser parameter is null or undefined
- An error occurs during import (logs a warning and returns undefined)

---

## resolveSkipAndOnlyDirectives() \{#resolveskipandonlydirectives\}

```ts
function resolveSkipAndOnlyDirectives(
  onlyDocDirective,
  skipDocDirective,
  schema,
): GraphQLDirective[][];
```

Defined in: core/src/generator.ts:295

Resolves and retrieves GraphQL directive objects from the schema based on their names.

Takes two lists of directive names (for "only" and "skip" documentation directives),
looks them up in the provided GraphQL schema, and returns the resolved directive objects.

### Parameters

#### onlyDocDirective

`Maybe`&lt;`DirectiveName` \| `DirectiveName`[]&gt;

A directive name or array of directive names for "only" documentation filtering

#### skipDocDirective

`Maybe`&lt;`DirectiveName` \| `DirectiveName`[]&gt;

A directive name or array of directive names for "skip" documentation filtering

#### schema

`GraphQLSchema`

The GraphQL schema to resolve directives from

### Returns

`GraphQLDirective`[][]

A tuple containing two arrays: the first with resolved "only" directives,
the second with resolved "skip" directives. Only defined directives are included.

---

## graphql-config

GraphQL Markdown configuration utilities

This module provides utilities for loading and processing GraphQL configuration
using the graphql-config package.

## EXTENSION_NAME \{#extension_name\}

```ts
const EXTENSION_NAME: "graphql-markdown";
```

Defined in: core/src/graphql-config.ts:31

The name of the GraphQL Markdown extension.
Used to identify the extension in graphql-config.

---

## graphQLConfigExtension \{#graphqlconfigextension\}

```ts
const graphQLConfigExtension: GraphQLExtensionDeclaration;
```

Defined in: core/src/graphql-config.ts:46

GraphQL extension declaration for graphql-config.

### Returns

The extension configuration object with name property.

### Example

```typescript
// In graphql-config setup
const config = await loadConfig({
  extensions: [graphQLConfigExtension],
});
```

---

## loadConfiguration() \{#loadconfiguration\}

```ts
function loadConfiguration(
  id,
  options?,
  throwOptions?,
): Promise<Maybe<Readonly<ExtensionProjectConfig>>>;
```

Defined in: core/src/graphql-config.ts:142

Loads the GraphQL Markdown configuration from graphql-config.

This function attempts to load the GraphQL config and extract the
GraphQL Markdown extension configuration for the specified project ID.
It also normalizes schema configurations.

### Parameters

#### id

`Maybe`&lt;`string`&gt;

The project ID to load configuration for.

#### options?

`Maybe`&lt;`PackageOptionsConfig`&gt;

Optional package options to apply.

#### throwOptions?

`ThrowOptions` = `DEFAULT_THROW_OPTIONS`

Options for controlling throw behavior.

### Returns

`Promise`&lt;`Maybe`&lt;`Readonly`&lt;`ExtensionProjectConfig`&gt;&gt;&gt;

The extension project configuration if found, otherwise `undefined`.

### Throws

Will throw an error if throwOnMissing or throwOnEmpty is true and
the corresponding condition is met.

### Example

```typescript
// Basic usage
const config = await loadConfiguration("my-project");

// With options and throw behavior
const config = await loadConfiguration(
  "my-project",
  { baseDir: "./src" },
  { throwOnMissing: true, throwOnEmpty: false },
);
```

---

## setLoaderOptions() \{#setloaderoptions\}

```ts
function setLoaderOptions(loaders, options): LoaderOption;
```

Defined in: core/src/graphql-config.ts:94

Sets loader options for GraphQL Markdown loaders.

This function takes a LoaderOption object and merges the provided options
with any existing options for each loader.

### Parameters

#### loaders

`LoaderOption`

The loader configuration object.

#### options

`PackageOptionsConfig`

The package options to apply to loaders.

### Returns

`LoaderOption`

The updated loader configuration.

### Example

```typescript
const loaders = {
  TypeScriptLoader: {
    module: "@graphql-markdown/typescript-loader",
    options: { baseDir: "./src" },
  },
};
const options = { outputDir: "./docs" };
const updatedLoaders = setLoaderOptions(loaders, options);
// Result: loaders with { baseDir: "./src", outputDir: "./docs" }
```

---

## builder

Option builder for handling CLI/config/default option precedence.

This utility provides a fluent interface for merging options from multiple
sources (CLI, config file, defaults) with consistent precedence rules:

1. CLI options (highest priority)
2. Config file options
3. Default values (lowest priority)

Precedence is enforced semantically via the setIfProvided() method,
regardless of the order in which methods are called. Each value tracks its
source, and only higher-precedence sources can override existing values.

Eliminates repetitive if/coalesce patterns throughout the codebase.

## OptionBuilder \{#optionbuilder\}

Defined in: core/src/options/builder.ts:49

Builder for constructing options from multiple sources with priority precedence.

Precedence is enforced semantically via source tracking, not by call order.
CLI values always override config values, which always override defaults,
regardless of the order in which methods are called.

### Example

```typescript
const options = new OptionBuilder<MyOptions>()
  // Add in order: default -> config -> cli
  .addDefault(false, "pretty")
  .addFromConfig(undefined, "pretty")
  .addFromCli(true, "pretty") // CLI overrides default
  .addDefault("/", "baseURL")
  .addFromConfig("/api", "baseURL") // Config overrides default
  .addFromCli(undefined, "baseURL")
  .build();
// Result: { pretty: true, baseURL: "/api" }
```

### Type Parameters

#### T

`T` _extends_ `Record`&lt;`string`, `unknown`&gt;

The type of the options object being built

### Constructors

#### Constructor

```ts
new OptionBuilder<T>(): OptionBuilder<T>;
```

##### Returns

[`OptionBuilder`](#optionbuilder)&lt;`T`&gt;

### Methods

#### addDefault() \{#adddefault\}

```ts
addDefault<K>(value, key): this;
```

Defined in: core/src/options/builder.ts:73

Adds a default value (lowest priority).
Sets a value that can be overwritten by config or CLI options.
This method can be called at any time; precedence is enforced semantically.

##### Type Parameters

###### K

`K` _extends_ `string` \| `number` \| `symbol`

##### Parameters

###### value

`Maybe`&lt;`T`\[`K`\]&gt;

The default value

###### key

`K`

The key to store the value under

##### Returns

`this`

This builder for method chaining

##### Example

```typescript
builder.addDefault(3000, "port");
```

#### addFromCli() \{#addfromcli\}

```ts
addFromCli<K>(value, key): this;
```

Defined in: core/src/options/builder.ts:109

Adds a value from CLI options if provided (highest priority).
Can override both default and config values for this key.
This method can be called at any time; precedence is enforced semantically.

##### Type Parameters

###### K

`K` _extends_ `string` \| `number` \| `symbol`

##### Parameters

###### value

`Maybe`&lt;`T`\[`K`\]&gt;

The CLI option value

###### key

`K`

The key to store the value under

##### Returns

`this`

This builder for method chaining

##### Example

```typescript
builder.addFromCli(cliOpts.port, "port");
```

#### addFromConfig() \{#addfromconfig\}

```ts
addFromConfig<K>(value, key): this;
```

Defined in: core/src/options/builder.ts:91

Adds a value from config file if provided (medium priority).
Can override default values if the config value exists.
This method can be called at any time; precedence is enforced semantically.

##### Type Parameters

###### K

`K` _extends_ `string` \| `number` \| `symbol`

##### Parameters

###### value

`Maybe`&lt;`T`\[`K`\]&gt;

The config file option value

###### key

`K`

The key to store the value under

##### Returns

`this`

This builder for method chaining

##### Example

```typescript
builder.addFromConfig(config.port, "port");
```

#### build() \{#build\}

```ts
build(): Partial<T>;
```

Defined in: core/src/options/builder.ts:190

Returns the built options object with all accumulated values.
The object contains all keys that were set during the building process.

Note: The returned object may be a partial object containing only the keys
that were set. Callers should handle potentially missing properties.
Returns a defensive copy of the object to prevent external mutations of
internal state. Arrays and objects are shallow-copied to protect against
external modifications.

##### Returns

`Partial`&lt;`T`&gt;

The constructed options object with type `Partial<T>` (may not have all properties of `T`)

#### get() \{#get\}

```ts
get<K>(key): T[K] | undefined;
```

Defined in: core/src/options/builder.ts:167

Gets the current value for a key without building.
Useful for conditional logic during building.
Returns a shallow copy for arrays and objects to prevent external mutations.
Note: Nested objects and arrays are not deep copied.

##### Type Parameters

###### K

`K` _extends_ `string` \| `number` \| `symbol`

##### Parameters

###### key

`K`

The key to get

##### Returns

`T`\[`K`\] \| `undefined`

The current value for the key, or `undefined` if not set

#### transform() \{#transform\}

```ts
transform<K>(key, fn): this;
```

Defined in: core/src/options/builder.ts:126

Transforms a value using a function if the key exists.
Useful for processing values after they've been set.

##### Type Parameters

###### K

`K` _extends_ `string` \| `number` \| `symbol`

##### Parameters

###### key

`K`

The key to transform

###### fn

(`v`) => `T`\[`K`\]

Function that transforms the current value

##### Returns

`this`

This builder for method chaining

##### Example

```typescript
builder.transform("path", (p) => resolve(p));
```

#### transformIf() \{#transformif\}

```ts
transformIf<K>(
   key,
   predicate,
   fn): this;
```

Defined in: core/src/options/builder.ts:147

Conditionally applies a transformation if a predicate is true.
Useful for applying different transformations based on other values.

##### Type Parameters

###### K

`K` _extends_ `string` \| `number` \| `symbol`

##### Parameters

###### key

`K`

The key to potentially transform

###### predicate

(`merged`) => `boolean`

Function that determines if transformation should apply

###### fn

(`v`) => `T`\[`K`\]

Function that transforms the value if predicate is true

##### Returns

`this`

This builder for method chaining

##### Example

```typescript
builder.transformIf(
  "path",
  () => force,
  (p) => resolve(p),
);
```

---

## printer

Printer loader helpers for bootstrapping GraphQL-Markdown renderers.

## getPrinter() \{#getprinter\}

```ts
function getPrinter(
  printerModule?,
  config?,
  options?,
  formatter?,
  mdxDeclaration?,
  eventEmitter?,
): Promise<typeof IPrinter>;
```

Defined in: core/src/printer.ts:67

Loads and initializes a printer module for GraphQL schema documentation.

This function dynamically imports the specified printer module and initializes it
with the provided configuration and options. The printer is responsible for rendering
GraphQL schema documentation in the desired format.

### Parameters

#### printerModule?

`Maybe`&lt;`PackageName`&gt;

The name/path of the printer module to load

#### config?

`Maybe`&lt;`PrinterConfig`&gt;

Configuration for the printer including schema, baseURL, and linkRoot

#### options?

`Maybe`&lt;`PrinterOptions`&gt;

Additional options for customizing the printer's behavior

#### formatter?

`Partial`&lt;`Formatter`&gt;

Optional formatter functions for customizing output format (e.g., MDX)

#### mdxDeclaration?

`Maybe`&lt;`string`&gt;

#### eventEmitter?

`Maybe`&lt;`PrinterEventEmitter`&gt;

### Returns

`Promise`&lt;_typeof_ `IPrinter`&gt;

A promise that resolves to the initialized Printer instance

### Throws

Will throw an error if printerModule is not a string

### Throws

Will throw an error if config is not provided

### Throws

Will throw an error if the module specified by printerModule cannot be found

### Example

```typescript

const schema = buildSchema(`
  type Query {
    hello: String
  }
`);

const printer = await getPrinter(
  "@graphql-markdown/printer-legacy",
  {
    schema,
    baseURL: "/docs",
    linkRoot: "graphql",
  },
  {
    printTypeOptions: { includeDeprecationReasons: true },
  },
);

const output = printer.printSchema();
```

---

## renderer

## Renderer \{#renderer\}

Defined in: core/src/renderer.ts:335

Core renderer class responsible for generating documentation files from GraphQL schema entities.
Handles the conversion of schema types to markdown/MDX documentation with proper organization.

HIERARCHY LEVELS WHEN categorySort IS ENABLED:

- Level 0 (root): Query, Mutation, Subscription, Custom Groups → 01-Query, 02-Mutation, etc.
- Level 1 (under root): Specific types within each root → 01-Objects, 02-Enums, etc.

Each level has its own CategoryPositionManager that restarts numbering at 1.

### Example

```ts

```

### Constructors

#### Constructor

```ts
new Renderer(
   printer,
   outputDir,
   baseURL,
   group,
   prettify,
   docOptions,
   mdxExtension): Renderer;
```

Defined in: core/src/renderer.ts:360

Creates a new Renderer instance.

##### Parameters

###### printer

_typeof_ `IPrinter`

The printer instance used to convert GraphQL types to markdown

###### outputDir

`string`

Directory where documentation will be generated

###### baseURL

`string`

Base URL for the documentation

###### group

`Maybe`&lt;`Partial`&lt;`Record`&lt;`SchemaEntity`, `Record`&lt;`string`, `Maybe`&lt;`string`&gt;&gt;&gt;&gt;&gt;

Optional grouping configuration for schema entities

###### prettify

`boolean`

Whether to format the generated markdown

###### docOptions

`Maybe`&lt;`RendererDocOptions`&gt;

Additional documentation options

###### mdxExtension

`string`

Optional MDX file extension to use

##### Returns

[`Renderer`](#renderer)

##### Example

```ts

```

### Properties

#### baseURL \{#baseurl\}

```ts
readonly baseURL: string;
```

Defined in: core/src/renderer.ts:338

#### group \{#group\}

```ts
readonly group: Maybe<Partial<Record<SchemaEntity, Record<string, Maybe<string>>>>>;
```

Defined in: core/src/renderer.ts:336

#### mdxExtension \{#mdxextension\}

```ts
readonly mdxExtension: string;
```

Defined in: core/src/renderer.ts:341

#### options \{#options\}

```ts
readonly options: Maybe<RendererDocOptions>;
```

Defined in: core/src/renderer.ts:340

#### outputDir \{#outputdir\}

```ts
readonly outputDir: string;
```

Defined in: core/src/renderer.ts:337

#### prettify \{#prettify\}

```ts
readonly prettify: boolean;
```

Defined in: core/src/renderer.ts:339

### Methods

#### generateCategoryMetafileType() \{#generatecategorymetafiletype\}

```ts
generateCategoryMetafileType(
   type,
   name,
   rootTypeName): Promise<string>;
```

Defined in: core/src/renderer.ts:463

Generates the directory path and metafiles for a specific schema entity type.
Creates the appropriate directory structure based on configuration options.

##### Parameters

###### type

`unknown`

The schema entity type

###### name

`string`

The name of the schema entity

###### rootTypeName

`SchemaEntity`

The root type name this entity belongs to

##### Returns

`Promise`&lt;`string`&gt;

The generated directory path

##### Example

```ts

```

#### generateIndexMetafile() \{#generateindexmetafile\}

```ts
generateIndexMetafile(
   dirPath,
   category,
   options?): Promise<void>;
```

Defined in: core/src/renderer.ts:408

Generates an index metafile for a category directory if MDX support is available.

##### Parameters

###### dirPath

`string`

The directory path where the index should be created

###### category

`string`

The category name

###### options?

[`CategoryMetafileOptions`](#categorymetafileoptions)

Configuration options for the index

##### Returns

`Promise`&lt;`void`&gt;

Promise that resolves when the index is generated

##### Example

```typescript
await renderer.generateIndexMetafile("docs/types", "Types", {
  collapsible: true,
  collapsed: false,
});
```

#### preCollectCategories() \{#precollectcategories\}

```ts
preCollectCategories(rootTypeNames): void;
```

Defined in: core/src/renderer.ts:753

Pre-collects all category names that will be generated during rendering.
This allows the position manager to assign consistent positions before
any files are written.

HIERARCHY LEVELS:

- Root level: Query, Mutation, Subscription, Deprecated (when grouped), custom root groups
- Nested level: operations/types (API groups), custom groups under roots

CRITICAL: Categories registered must match the NAMES USED BY THE PRINTER
when generating links. The printer uses plural forms from ROOT_TYPE_LOCALE:
"operations", "objects", "directives", "enums", "inputs", "interfaces",
"mutations", "queries", "scalars", "subscriptions", "unions"

NOT the folder names: "operations", "types"

##### Parameters

###### rootTypeNames

`string`[]

Array of root type names from the schema

##### Returns

`void`

#### renderHomepage() \{#renderhomepage\}

```ts
renderHomepage(homepageLocation): Promise<void>;
```

Defined in: core/src/renderer.ts:803

Renders the homepage for the documentation from a template file.
Replaces placeholders in the template with actual values.

##### Parameters

###### homepageLocation

`Maybe`&lt;`string`&gt;

Path to the homepage template file

##### Returns

`Promise`&lt;`void`&gt;

Promise that resolves when the homepage is rendered

##### Example

```ts

```

#### renderRootTypes() \{#renderroottypes\}

```ts
renderRootTypes(rootTypeName, type): Promise<Maybe<Maybe<Category>[]>>;
```

Defined in: core/src/renderer.ts:547

Renders all types within a root type category (e.g., all Query types).

##### Parameters

###### rootTypeName

`SchemaEntity`

The name of the root type (e.g., "Query", "Mutation")

###### type

`unknown`

The type object containing all entities to render

##### Returns

`Promise`&lt;`Maybe`&lt;`Maybe`&lt;`Category`&gt;[]&gt;&gt;

Array of rendered categories or undefined

##### Example

```ts

```

#### renderTypeEntities() \{#rendertypeentities\}

```ts
renderTypeEntities(
   dirPath,
   name,
   type,
   operationNamespaceParts?): Promise<Maybe<Category>>;
```

Defined in: core/src/renderer.ts:614

Renders documentation for a specific type entity and saves it to a file.

##### Parameters

###### dirPath

`string`

The directory path where the file should be saved

###### name

`string`

The name of the type entity

###### type

`unknown`

The type entity to render

###### operationNamespaceParts?

`string`[]

##### Returns

`Promise`&lt;`Maybe`&lt;`Category`&gt;&gt;

The category information for the rendered entity or undefined

##### Example

```ts

```

---

## CategoryMetafileOptions \{#categorymetafileoptions\}

Defined in: core/src/renderer.ts:219

Configuration options for category metafiles in the documentation.
These options control the appearance and behavior of category sections in the sidebar.

CategoryMetafileOptions

### Example

```typescript
const options: CategoryMetafileOptions = {
  collapsible: true,
  collapsed: false,
  sidebarPosition: SidebarPosition.FIRST,
  styleClass: CATEGORY_STYLE_CLASS.API,
};
```

### Properties

#### collapsed? \{#collapsed\}

```ts
optional collapsed?: boolean;
```

Defined in: core/src/renderer.ts:221

Whether the category should be initially collapsed

#### collapsible? \{#collapsible\}

```ts
optional collapsible?: boolean;
```

Defined in: core/src/renderer.ts:220

Whether the category should be collapsible in the sidebar

#### sidebarPosition? \{#sidebarposition\}

```ts
optional sidebarPosition?: number;
```

Defined in: core/src/renderer.ts:222

Custom position in the sidebar (lower numbers appear first)

#### styleClass? \{#styleclass\}

```ts
optional styleClass?: string;
```

Defined in: core/src/renderer.ts:223

CSS class to apply to the category for styling

---

## API_GROUPS \{#api_groups\}

```ts
const API_GROUPS: Required<ApiGroupOverrideType>;
```

Defined in: core/src/renderer.ts:124

Default group names for API types and non-API types.
This constant provides the base folder structure for organizing GraphQL schema entities.
Can be overridden via ApiGroupOverrideType in configuration.

### Example

```typescript
// Default structure
const defaultGroups = API_GROUPS;
// { operations: "operations", types: "types" }

// With custom override
const customGroups = { ...API_GROUPS, operations: "queries-and-mutations" };
```

### See

[getApiGroupFolder](#getapigroupfolder) For usage with type categorization

---

## getApiGroupFolder() \{#getapigroupfolder\}

```ts
function getApiGroupFolder(type, groups?): string;
```

Defined in: core/src/renderer.ts:145

Determines the appropriate folder for a GraphQL schema entity based on its type.

### Parameters

#### type

`unknown`

The GraphQL schema entity to categorize

#### groups?

`Maybe`&lt;`boolean` \| `ApiGroupOverrideType`&gt;

Optional custom group naming configuration

### Returns

`string`

The folder name where the entity should be placed

### Example

```typescript
// With default groups
const folder = getApiGroupFolder(queryType); // Returns "operations"

// With custom groups
const folder = getApiGroupFolder(objectType, { operations: "queries" }); // Returns appropriate folder
```

---

## getRenderer() \{#getrenderer\}

```ts
function getRenderer(
  printer,
  outputDir,
  baseURL,
  group,
  prettify,
  docOptions,
  mdxExtension,
): Promise<Renderer>;
```

Defined in: core/src/renderer.ts:1035

Factory function to create and initialize a Renderer instance.
Creates the output directory and returns a configured renderer.

### Parameters

#### printer

_typeof_ `IPrinter`

The printer instance to use for rendering types

#### outputDir

`string`

The output directory for generated documentation

#### baseURL

`string`

The base URL for the documentation

#### group

`Maybe`&lt;`Partial`&lt;`Record`&lt;`SchemaEntity`, `Record`&lt;`string`, `Maybe`&lt;`string`&gt;&gt;&gt;&gt;&gt;

Optional grouping configuration

#### prettify

`boolean`

Whether to prettify the output markdown

#### docOptions

`Maybe`&lt;`RendererDocOptions`&gt;

Additional documentation options

#### mdxExtension

`string`

Extension to use for MDX files

### Returns

`Promise`&lt;[`Renderer`](#renderer)&gt;

A configured Renderer instance

### Example

```typescript
const renderer = await getRenderer(
  myPrinter,
  "./docs",
  "/api",
  groupConfig,
  true,
  { force: true, index: true },
);
```

---

## diff(Api)

Schema comparison module for GraphQL Markdown.
Provides utilities to compare GraphQL schemas and detect changes.

## CompareMethod \{#comparemethod\}

Defined in: index.ts:32

Comparison methods used to determine if a schema has changed.

### Enumeration Members

#### DIFF \{#diff\}

```ts
DIFF: "SCHEMA-DIFF";
```

Defined in: index.ts:34

Compare schemas by diffing the content

#### FORCE \{#force\}

```ts
FORCE: "FORCE";
```

Defined in: index.ts:38

Force regeneration regardless of changes

#### HASH \{#hash\}

```ts
HASH: "SCHEMA-HASH";
```

Defined in: index.ts:36

Compare schemas by comparing hash values

#### NONE \{#none\}

```ts
NONE: "NONE";
```

Defined in: index.ts:40

Skip comparison and assume no changes

---

## checkSchemaChanges \{#checkschemachanges\}

```ts
const checkSchemaChanges: FunctionCheckSchemaChanges;
```

Defined in: index.ts:80

Checks if a schema has changed compared to a previous version.
Uses either diff or hash-based comparison methods based on the method parameter.

### Param

The current GraphQL schema

### Param

Directory where schema or hash files will be saved

### Param

Comparison method to use (defaults to DIFF)

### Returns

A promise resolving to a boolean indicating whether the schema has changed

---

## SCHEMA_HASH_FILE \{#schema_hash_file\}

```ts
const SCHEMA_HASH_FILE: ".schema";
```

Defined in: index.ts:25

File name for storing schema hash

---

## SCHEMA_REF \{#schema_ref\}

```ts
const SCHEMA_REF: "schema.graphql";
```

Defined in: index.ts:27

File name for storing schema reference

---

## getDiff() \{#getdiff\}

```ts
function getDiff(schemaNew, schemaOldLocation): Promise<Change<any>[]>;
```

Defined in: index.ts:61

Compares a new schema against an existing schema file and returns the differences.

### Parameters

#### schemaNew

`GraphQLSchema`

The new GraphQL schema to compare

#### schemaOldLocation

`string`

File path to the old schema

### Returns

`Promise`&lt;`Change`&lt;`any`&gt;[]&gt;

A promise resolving to an array of schema changes

---

## getSchemaHash() \{#getschemahash\}

```ts
function getSchemaHash(schema): string;
```

Defined in: index.ts:49

Generates a SHA-256 hash for a GraphQL schema.

### Parameters

#### schema

`GraphQLSchema`

The GraphQL schema to generate a hash for

### Returns

`string`

A SHA-256 hash string representing the schema

---

## index

Docusaurus integration for running GraphQL-Markdown and wiring CLI commands.

## default() \{#default\}

```ts
function default(_, options): Promise<Plugin>;
```

Defined in: index.ts:31

Docusaurus plugin wrapper that wires GraphQL-Markdown into the build,
optionally running the CLI during `docusaurus build` and registering
the `graphql-to-doc` command on the local CLI.

### Parameters

#### \_

`LoadContext`

Load context (unused).

#### options

`ConfigOptions` & `Partial`&lt;`ExperimentalConfigOptions`&gt; & `Partial`&lt;`PluginOptions`&gt;

GraphQL-Markdown CLI options plus Docusaurus plugin options.

### Returns

`Promise`&lt;`Plugin`&gt;

A configured Docusaurus plugin instance.

---

## category

## beforeGenerateIndexMetafileHook() \{#beforegenerateindexmetafilehook\}

```ts
function beforeGenerateIndexMetafileHook(event): Promise<void>;
```

Defined in: mdx/category.ts:31

Hook that materializes a `_category_.yml` file before Docusaurus indexes
a directory, ensuring generated bundles have labels, ordering, and
optional generated-index metadata even when the folder was produced by the CLI.

### Parameters

#### event

Hook payload containing the target directory, category name, and generator options.

##### data

\{
`category`: `string`;
`dirPath`: `string`;
`options?`: `Record`&lt;`string`, `unknown`&gt;;
\}

##### data.category

`string`

##### data.dirPath

`string`

##### data.options?

`Record`&lt;`string`, `unknown`&gt;

### Returns

`Promise`&lt;`void`&gt;

---

## components

## mdxDeclaration \{#mdxdeclaration\}

```ts
const mdxDeclaration: MDXString;
```

Defined in: mdx/components.ts:20

String literal that declares the React helpers (`Bullet`, `SpecifiedBy`, etc.)
which GraphQL-Markdown prepends to every generated MDX file.

---

## mdx

## createMDXFormatter() \{#createmdxformatter\}

```ts
function createMDXFormatter(meta?): Formatter;
```

Defined in: mdx/index.ts:159

Creates an MDX formatter for Docusaurus documentation.

The MDX formatter produces MDX/HTML markup compatible with Docusaurus.
It uses helper components like `<Badge>`, `<Bullet>`, and `<SpecifiedBy>`,
and emits native `<details>/<summary>` blocks for collapsible sections.

### Parameters

#### meta?

`Maybe`&lt;`MetaInfo`&gt;

Optional metadata for framework-specific formatting

### Returns

`Formatter`

A complete Formatter implementation for MDX output

### Example

```typescript

const formatter = createMDXFormatter({ generatorFrameworkName: "docusaurus" });
const badge = formatter.formatMDXBadge({ text: "Required" });
// '<Badge class="badge badge--secondary " text="Required"/>'
```

---

## formatMDXAdmonition() \{#formatmdxadmonition\}

```ts
function formatMDXAdmonition(param, meta): MDXString;
```

Defined in: mdx/index.ts:52

Formats an admonition block in MDX format

### Parameters

#### param

`AdmonitionType`

The admonition configuration object

#### meta

`Maybe`&lt;`MetaInfo`&gt;

Optional metadata for generator configuration

### Returns

`MDXString`

Formatted MDX string for the admonition

---

## formatMDXBadge() \{#formatmdxbadge\}

```ts
function formatMDXBadge(param): MDXString;
```

Defined in: mdx/index.ts:40

Formats a Badge inline-block in MDX format

### Parameters

#### param

`Badge`

The badge configuration object

### Returns

`MDXString`

Formatted MDX string for the badge

---

## formatMDXBullet() \{#formatmdxbullet\}

```ts
function formatMDXBullet(text?): MDXString;
```

Defined in: mdx/index.ts:69

Creates a bullet point element in MDX format

### Parameters

#### text?

`string` = `""`

Optional text to append after the bullet point

### Returns

`MDXString`

Formatted MDX string for the bullet point

---

## formatMDXDetails() \{#formatmdxdetails\}

```ts
function formatMDXDetails(param): MDXString;
```

Defined in: mdx/index.ts:78

Creates a collapsible details section in MDX format

### Parameters

#### param

`CollapsibleOption`

The collapsible section configuration

### Returns

`MDXString`

Formatted MDX string for the collapsible section

---

## formatMDXFrontmatter() \{#formatmdxfrontmatter\}

```ts
function formatMDXFrontmatter(_props, formatted): MDXString;
```

Defined in: mdx/index.ts:129

Default frontmatter formatter for MDX.

### Parameters

#### \_props

`Maybe`&lt;`FrontMatterOptions`&gt;

The front matter options (unused)

#### formatted

`Maybe`&lt;`string`[]&gt;

The formatted front matter as an array of strings

### Returns

`MDXString`

Formatted MDX string for the front matter

---

## formatMDXLink() \{#formatmdxlink\}

```ts
function formatMDXLink(param): TypeLink;
```

Defined in: mdx/index.ts:115

Formats a link in MDX format

### Parameters

#### param

`TypeLink`

The link configuration object

### Returns

`TypeLink`

Formatted MDX link object

---

## formatMDXNameEntity() \{#formatmdxnameentity\}

```ts
function formatMDXNameEntity(name, parentType?): MDXString;
```

Defined in: mdx/index.ts:102

Formats a name entity with optional parent type

### Parameters

#### name

`string`

The name to format

#### parentType?

`Maybe`&lt;`string`&gt;

Optional parent type to prefix the name

### Returns

`MDXString`

Formatted MDX string for the name entity

---

## formatMDXSpecifiedByLink() \{#formatmdxspecifiedbylink\}

```ts
function formatMDXSpecifiedByLink(url): MDXString;
```

Defined in: mdx/index.ts:92

Creates a link to the specification documentation

### Parameters

#### url

`string`

The URL to the specification

### Returns

`MDXString`

Formatted MDX string for the specification link

---

## directive

Library supporting `customDirective` for directive based customization.

## See

[Option `customDirective`](https://graphql-markdown.dev/docs/advanced/custom-directive)

## WILDCARD_DIRECTIVE \{#wildcard_directive\}

```ts
const WILDCARD_DIRECTIVE: "*";
```

Defined in: packages/graphql/src/directive.ts:29

Wildcard `*` character for matching any directive name.

See [getCustomDirectiveOptions](#getcustomdirectiveoptions), [isCustomDirective](#iscustomdirective)

---

## getConstDirectiveMap() \{#getconstdirectivemap\}

```ts
function getConstDirectiveMap(
  entity,
  customDirectiveMap,
): Maybe<CustomDirectiveMap>;
```

Defined in: packages/graphql/src/directive.ts:249

Returns a map of custom directives for a schema entity.

### Parameters

#### entity

`unknown`

a GraphQL schema entity.

#### customDirectiveMap

`Maybe`&lt;`CustomDirectiveMap`&gt;

a custom directive map (see [getCustomDirectives](#getcustomdirectives)).

### Returns

`Maybe`&lt;`CustomDirectiveMap`&gt;

A map of GraphQL directives matching the custom directives defined, else `undefined`.

### Example

```js

const schema = buildSchema(`
    directive @testA(
      arg: ArgEnum = ARGA
    ) on OBJECT | FIELD_DEFINITION

    directive @testB(
      argA: Int!,
      argB: [String!]
    ) on FIELD_DEFINITION

    enum ArgEnum {
      ARGA
      ARGB
      ARGC
    }

    type Test @testA {
      id: ID!
      fieldA: [String!]
        @testA(arg: ARGC)
        @testB(argA: 10, argB: ["testArgB"])
    }

    type TestWithoutDirective {
      id: ID!
    }
  `);

const customDirectives = {
  testA: {
    type: schema.getDirective("testA"),
    descriptor: (_, constDirectiveType) => `${constDirectiveType.name}`;
  },
};

const map = getConstDirectiveMap(schema.getType("Test"), customDirectives);
// Expected result: {
//   "descriptor": (_, constDirectiveType) => `${constDirectiveType.name}`,
//   "type": schema.getDirective("testA"),
// }

```

---

## getCustomDirectiveOptions() \{#getcustomdirectiveoptions\}

```ts
function getCustomDirectiveOptions(
  schemaDirectiveName,
  customDirectiveOptions,
): Maybe<Partial<Record<CustomDirectiveResolver, CustomDirectiveFunction>>>;
```

Defined in: packages/graphql/src/directive.ts:77

Returns a record set of custom handlers from a directive by name.

### Parameters

#### schemaDirectiveName

`DirectiveName`

the GraphQL directive name.

#### customDirectiveOptions

`CustomDirective`

the `customDirective` option.

### Returns

`Maybe`&lt;`Partial`&lt;`Record`&lt;`CustomDirectiveResolver`, `CustomDirectiveFunction`&gt;&gt;&gt;

a record set of custom handlers for the matching directive (or if `*` is declared), or `undefined` if no match.

### Example

```js

const customDirectiveOptions = {
  "*": {
    descriptor: (_, constDirectiveType) => `Wildcard ${constDirectiveType.name}`;
  },
};

const customDirectives = getCustomDirectiveOptions("testB", customDirectiveOptions);

// Expected result: {
//   "descriptor": (_, constDirectiveType) => `Wildcard ${constDirectiveType.name}`,
//   "type": "@testB",
// }
```

---

## getCustomDirectives() \{#getcustomdirectives\}

```ts
function getCustomDirectives(
  schemaMap,
  customDirectiveOptions?,
): Maybe<CustomDirectiveMap>;
```

Defined in: packages/graphql/src/directive.ts:151

Returns a custom directives map with custom handlers from `customDirective`.

### Parameters

#### schemaMap

`Pick`&lt;`SchemaMap`, `"directives"`&gt;

the GraphQL schema map returned by getSchemaMap

#### customDirectiveOptions?

`Maybe`&lt;`CustomDirective`&gt;

the `customDirective` option.

### Returns

`Maybe`&lt;`CustomDirectiveMap`&gt;

a custom directive map, or `undefined` if no match.

### Example

```js

const schema = buildSchema(`
  directive @testA(
    arg: ArgEnum = ARGA
  ) on OBJECT | FIELD_DEFINITION
  directive @testB(
    argA: Int!,
    argB: [String!]
  ) on FIELD_DEFINITION
  enum ArgEnum {
    ARGA
    ARGB
    ARGC
  }
`);

const schemaMap = {
  directives: {
    testA: schema.getDirective("testA"),
    testB: schema.getDirective("testB"),
  },
};

const customDirectiveOptions = {
  testA: {
    descriptor: (_, constDirectiveType) => `Named directive ${constDirectiveType.name}`;
  },
  "*": {
    descriptor: (_, constDirectiveType) => `Wildcard ${constDirectiveType.name}`;
  },
};

const customDirectives = getCustomDirectives(schemaMap, customDirectiveOptions);

// Expected result: {
//   "testA": {
//     "descriptor": (_, constDirectiveType) => `Named directive ${constDirectiveType.name}`,
//     "type": "@testA",
//   },
//   "testB": {
//     "descriptor": (_, constDirectiveType) => `Wildcard ${constDirectiveType.name}`,
//     "type": "@testB",
//   },
// }
```

---

## isCustomDirective() \{#iscustomdirective\}

```ts
function isCustomDirective(
  schemaDirectiveName,
  customDirectiveOptions,
): boolean;
```

Defined in: packages/graphql/src/directive.ts:40

Checks if a directive name is referenced in `customDirective` option.

### Parameters

#### schemaDirectiveName

`DirectiveName`

the GraphQL directive name.

#### customDirectiveOptions

`CustomDirective`

the `customDirective` option.

### Returns

`boolean`

`true` if the directive is declared or `*` is declared in `customDirective` option, else `false`.

---

## formatter

Internal library of helpers for formatting GraphQL values.

## getFormattedDefaultValue() \{#getformatteddefaultvalue\}

```ts
function getFormattedDefaultValue<T>(entity): Maybe<string | T>;
```

Defined in: packages/graphql/src/formatter.ts:130

Returns a printable formatted value for a GraphQL type.
This is the generic function.

### Type Parameters

#### T

`T`

### Parameters

#### entity

`GraphQLSchemaEntity`&lt;`T`&gt;

the GraphQL schema entity processed.

### Returns

`Maybe`&lt;`string` \| `T`&gt;

a printable formatted value.

---

## group

Library supporting `groupByDirective` for grouping GraphQL schema entities.

## See

[Option `groupByDirective`](https://graphql-markdown.dev/docs/advanced/group-by-directive)

## getGroupName() \{#getgroupname\}

```ts
function getGroupName<T>(type, groupByDirective): Maybe<string>;
```

Defined in: packages/graphql/src/group.ts:72

Gets the group name for a schema type based on the directive information.

### Type Parameters

#### T

`T`

### Parameters

#### type

`T`

a GraphQL schema named type

#### groupByDirective

`Maybe`&lt;`GroupByDirectiveOptions`&gt;

the `groupByDirective` option.

### Returns

`Maybe`&lt;`string`&gt;

the group name matching the type, or `groupByDirective.fallback` if no match found.

### Example

```js

const schema = buildSchema(`
  directive @doc(
    category: String
  ) on OBJECT | INPUT_OBJECT | UNION | ENUM | INTERFACE | FIELD_DEFINITION | ARGUMENT_DEFINITION
  type Unicorn {
    name: String!
  }
  type Bird @doc(category: "animal") {
    name: String!
  }
  type Fish {
    name: String!
  }
  type Elf @doc(category: "fantasy") {
    name: String!
  }
  type Query {
    Fish: [Fish!]! @doc(category: "animal")
  }
`);

const groupOptions = {
  fallback: "common",
  directive: "doc",
  field: "category",
};

getGroupName(schema.getType("Bird"), groupOptions); // Expected result: "animal"

getGroupName(schema.getType("Unicorn"), groupOptions); // Expected result: "common"
```

---

## getGroups() \{#getgroups\}

```ts
function getGroups(
  schemaMap,
  groupByDirective,
): Maybe<Partial<Record<SchemaEntity, Record<string, Maybe<string>>>>>;
```

Defined in: packages/graphql/src/group.ts:173

Parses a GraphQL schema to build a map of entities with matching `groupByDirective` option.

### Parameters

#### schemaMap

`SchemaMap`

the GraphQL schema map returned by getSchemaMap

#### groupByDirective

`Maybe`&lt;`GroupByDirectiveOptions`&gt;

the `groupByDirective` option.

### Returns

`Maybe`&lt;`Partial`&lt;`Record`&lt;`SchemaEntity`, `Record`&lt;`string`, `Maybe`&lt;`string`&gt;&gt;&gt;&gt;&gt;

a map of entities with matching group name.

### Example

```js

const schema = buildSchema(`
  directive @doc(
    category: String
  ) on OBJECT | INPUT_OBJECT | UNION | ENUM | INTERFACE | FIELD_DEFINITION | ARGUMENT_DEFINITION
  type Unicorn {
    name: String!
  }
  type Bird @doc(category: "animal") {
    name: String!
  }
  type Fish {
    name: String!
  }
  type Elf @doc(category: "fantasy") {
    name: String!
  }
  type Query {
    Fish: [Fish!]! @doc(category: "animal")
  }
`);

const schemaMap = {
  objects: schema.getTypeMap(),
  queries: schema.getQueryType()?.getFields(),
};

const groupOptions = {
  fallback: "common",
  directive: "doc",
  field: "category",
};

const groupsMap = getGroups(schemaMap, groupOptions);

// Expected result: {
//   "objects": {
//     "Bird": "animal",
//     "Boolean": "common",
//     "Elf": "fantasy",
//     "Fish": "common",
//     "Query": "common",
//     "String": "common",
//     "Unicorn": "common",
//   },
//   "queries": {
//     "Fish": "animal",
//   },
// }
```

---

## guard

Custom GraphQL type guards and property guards.

## executableDirectiveLocation() \{#executabledirectivelocation\}

```ts
function executableDirectiveLocation(directive): boolean;
```

Defined in: packages/graphql/src/guard.ts:104

Checks if a directive is executable (related to operations).

### Parameters

#### directive

`GraphQLDirective`

a GraphQL directive.

### Returns

`boolean`

---

## instanceOf() \{#instanceof\}

```ts
function instanceOf<T>(obj, type): obj is () => T;
```

Defined in: packages/graphql/src/guard.ts:58

Checks if a GraphQL named type is of generic type `T`.

### Type Parameters

#### T

`T`

a GraphQL type to check against, eg `GraphQLObjectType`.

### Parameters

#### obj

`unknown`

a GraphQL named type from the GraphQL schema.

#### type

() => `T`

the GraphQL type `T`.

### Returns

`obj is () => T`

---

## isApiType() \{#isapitype\}

```ts
function isApiType(type): boolean;
```

Defined in: packages/graphql/src/guard.ts:140

Checks if a type belongs to API (operation related).

### Parameters

#### type

`unknown`

a GraphQL type.

### Returns

`boolean`

---

## isDeprecated() \{#isdeprecated\}

```ts
function isDeprecated<T>(obj): obj is DeprecatedType<T>;
```

Defined in: packages/graphql/src/guard.ts:79

Checks if a GraphQL named type is deprecated.

### Type Parameters

#### T

`T`

a GraphQL type to check against, eg `GraphQLObjectType`.

### Parameters

#### obj

`T`

an instance of `T`.

### Returns

`obj is DeprecatedType<T>`

---

## isGraphQLFieldType() \{#isgraphqlfieldtype\}

```ts
function isGraphQLFieldType(
  type,
): type is GraphQLField<unknown, unknown, unknown>;
```

Defined in: packages/graphql/src/guard.ts:39

Checks if a GraphQL named type is of type `GraphQLField`.

### Parameters

#### type

`unknown`

a GraphQL type.

### Returns

`type is GraphQLField<unknown, unknown, unknown>`

---

## isOperation() \{#isoperation\}

```ts
function isOperation(type): type is GraphQLOperationType;
```

Defined in: packages/graphql/src/guard.ts:94

Checks if a GraphQL type a GraphQL operation (query, mutation, subscription).

### Parameters

#### type

`unknown`

a GraphQL type.

### Returns

`type is GraphQLOperationType`

---

## isSystemType() \{#issystemtype\}

```ts
function isSystemType(type): boolean;
```

Defined in: packages/graphql/src/guard.ts:153

Checks if a type belongs to schema (schema type definition excluding operations related types).

### Parameters

#### type

`unknown`

a GraphQL type.

### Returns

`boolean`

---

## typeSystemDirectiveLocation() \{#typesystemdirectivelocation\}

```ts
function typeSystemDirectiveLocation(directive): boolean;
```

Defined in: packages/graphql/src/guard.ts:127

Checks if a directive is system (related to schema definition).

### Parameters

#### directive

`GraphQLDirective`

a GraphQL directive.

### Returns

`boolean`

---

## loader

Library for GraphQL schema loading and `loaders` config processing.

## getDocumentLoaders() \{#getdocumentloaders\}

```ts
function getDocumentLoaders(loadersList): Promise<Maybe<LoadSchemaOptions>>;
```

Defined in: packages/graphql/src/loader.ts:113

### Parameters

#### loadersList

`Maybe`&lt;`LoaderOption`&gt;

### Returns

`Promise`&lt;`Maybe`&lt;`LoadSchemaOptions`&gt;&gt;

---

## loadSchema() \{#loadschema\}

```ts
function loadSchema(schemaLocation, options): Promise<GraphQLSchema>;
```

Defined in: packages/graphql/src/loader.ts:50

### Parameters

#### schemaLocation

`string`

#### options

`LoadSchemaConfig`

### Returns

`Promise`&lt;`GraphQLSchema`&gt;

---

## relation

Library supporting `relatedTypeSection` for displaying relations between GraphQL schema entities.

## See

[Option `relatedTypeSection`](https://graphql-markdown.dev/docs/settings#printtypeoptions)

## getRelationOfField \{#getrelationoffield\}

```ts
const getRelationOfField: IGetRelation<RelationOfField>;
```

Defined in: packages/graphql/src/relation.ts:169

Returns a map of fields and arguments where the GraphQL schema type matches the type.

### See

mapRelationOf

### Type Param

the type of the GraphQL schema type.

### Type Param

the return type of map of relations (see IGetRelation).

### Param

the GraphQL schema type being processed.

### Param

a GraphQL schema map (see getSchemaMap).

### Returns

a record map of fields and arguments relations.

---

## getRelationOfImplementation \{#getrelationofimplementation\}

```ts
const getRelationOfImplementation: IGetRelation<RelationOfImplementation>;
```

Defined in: packages/graphql/src/relation.ts:371

Returns a map of types (unions or interfaces) where the GraphQL schema type is implemented.

### See

mapRelationOf

### Type Param

the type of the GraphQL schema type.

### Type Param

the return type of map of relations (see IGetRelation).

### Param

the GraphQL schema type being processed.

### Param

a GraphQL schema map (see getSchemaMap).

### Returns

a record map of unions or interfaces relations.

---

## getRelationOfInterface \{#getrelationofinterface\}

```ts
const getRelationOfInterface: IGetRelation<RelationOfInterface>;
```

Defined in: packages/graphql/src/relation.ts:314

Returns a map of interfaces where the GraphQL schema type is extended.

### See

mapRelationOf

### Type Param

the type of the GraphQL schema type.

### Type Param

the return type of map of relations (see IGetRelation).

### Param

the GraphQL schema type being processed.

### Param

a GraphQL schema map (see getSchemaMap).

### Returns

a record map of interfaces relations.

---

## getRelationOfReturn \{#getrelationofreturn\}

```ts
const getRelationOfReturn: IGetRelation<GraphQLOperationType>;
```

Defined in: packages/graphql/src/relation.ts:106

Returns a map of operations (queries, mutations, subscriptions) where the GraphQL schema type is the return type.

### See

mapRelationOf

### Type Param

the type of the GraphQL schema type.

### Type Param

the return type of map of relations (see IGetRelation).

### Param

the GraphQL schema type being processed.

### Param

a GraphQL schema map (see getSchemaMap).

### Returns

a record map of operations relations.

---

## getRelationOfUnion \{#getrelationofunion\}

```ts
const getRelationOfUnion: IGetRelation<GraphQLUnionType>;
```

Defined in: packages/graphql/src/relation.ts:258

Returns a map of unions where the GraphQL schema type is part of it.

### See

mapRelationOf

### Type Param

the type of the GraphQL schema type.

### Type Param

the return type of map of relations (see IGetRelation).

### Param

the GraphQL schema type being processed.

### Param

a GraphQL schema map (see getSchemaMap).

### Returns

a record map of unions relations.

---

## descriptor

Custom directive `descriptor` helper.

## See

[Option `customDirective.[directive].descriptor`](https://graphql-markdown.dev/docs/advanced/custom-directive#descriptor)

## directiveDescriptor() \{#directivedescriptor\}

```ts
function directiveDescriptor(directive, type?, descriptionTemplate?): string;
```

Defined in: directives/descriptor.ts:83

Helper for rendering custom description from schema directive on type.
This is an example on how to build a custom `descriptor` callback.

### Parameters

#### directive

`GraphQLDirective`

the schema directive to parse.

#### type?

`unknown`

the schema type to be processed for generating a custom description.

#### descriptionTemplate?

`string`

optional template literal-like string for rendering the description (see [interpolate](../utils/interpolate.md#interpolate)), if not present then the directive description will be used.

### Returns

`string`

a custom description based on directive value.

### Example

```js

const directive = new GraphQLDirective({
  name: "version",
  description: "Min version",
  locations: [],
  args: {
    major: { type: GraphQLInt, defaultValue: 0 },
    minor: { type: GraphQLInt, defaultValue: 0 },
    patch: { type: GraphQLInt, defaultValue: 0 },
  },
});

const type =
  new GraphQLScalarType() <
  string >
  {
    name: "FooBar",
    astNode: {
      kind: Kind.SCALAR_TYPE_DEFINITION,
      name: { kind: Kind.NAME, value: "FooBar" },
      directives: [
        {
          kind: Kind.DIRECTIVE,
          name: { kind: Kind.NAME, value: "version" },
          arguments: [
            {
              kind: Kind.ARGUMENT,
              name: { kind: Kind.NAME, value: "major" },
              value: { kind: Kind.INT, value: "2" },
            },
            {
              kind: Kind.ARGUMENT,
              name: { kind: Kind.NAME, value: "minor" },
              value: { kind: Kind.INT, value: "1" },
            },
            {
              kind: Kind.ARGUMENT,
              name: { kind: Kind.NAME, value: "patch" },
              value: { kind: Kind.INT, value: "3" },
            },
          ],
        },
      ],
    },
  };

directiveDescriptor(
  directive,
  type,
  "${description} is ${major}.${minor}.${patch}",
);
// Expected result: "Min version is 2.1.3"

directiveDescriptor(directive, type);
// Expected result: "Min version"

directiveDescriptor(
  directive,
  type,
  "Version should be at least ^${major}.${minor}.${patch}",
);
// Expected result: "Version should be at least ^2.1.3"
```

---

## tag

Custom directive `tag` helper.

## See

[Option `customDirective.[directive].tag`](https://graphql-markdown.dev/docs/advanced/custom-directive#tag)

## directiveTag() \{#directivetag\}

```ts
function directiveTag(directive, type?, classname?): Badge;
```

Defined in: directives/tag.ts:51

Helper for rendering custom description from schema directive on type.
This is an example on how to build a custom `tag` callback.

### Parameters

#### directive

`GraphQLDirective`

the schema directive to parse.

#### type?

`unknown`

the type being processed.

#### classname?

`string` = `"badge--secondary"`

optional CSS classname, `"badge--secondary"` by default.

### Returns

`Badge`

a custom description based on directive value.

### Example

```js

const directive = new GraphQLDirective({
  name: "auth",
  description: "Authentication required",
  locations: [],
});

const type =
  new GraphQLScalarType() <
  string >
  {
    name: "FooBar",
    astNode: {
      kind: Kind.SCALAR_TYPE_DEFINITION,
      name: { kind: Kind.NAME, value: "FooBar" },
      directives: [
        {
          kind: Kind.DIRECTIVE,
          name: { kind: Kind.NAME, value: "auth" },
        },
      ],
    },
  };

directiveTag(directive, type);
// Expected result: { text: "@auth", classname: "badge--secondary" }
```

---

## interpolate

Helpers utility functions library.

## getObjPath() \{#getobjpath\}

```ts
function getObjPath(path, obj, fallback?): unknown;
```

Defined in: utils/interpolate.ts:31

**`Internal`**

Returns the value of the specified property or nested property of an object using a string path.

### Parameters

#### path

`Maybe`&lt;`string`&gt;

property path as string.

#### obj

`unknown`

the key/value record object.

#### fallback?

`unknown` = `""`

optional fallback value to be returned if the path cannot be resolved.

### Returns

`unknown`

the property value if the path is resolved, else returns the `fallback` value.

### Example

```js

getObjPath("foo.bar", { foo: { bar: 42 } }); // Returns 42

getObjPath("foo.bak", { foo: { bar: 42 } }, "fallback"); // Returns "fallback"
```

---

## interpolate() \{#interpolate\}

```ts
function interpolate(template, variables, fallback?): string;
```

Defined in: utils/interpolate.ts:64

Interpolate a template literal-like string.

### Parameters

#### template

`string`

a string template literal-like.

#### variables

`Maybe`&lt;`Record`&lt;`string`, `unknown`&gt; & `object`&gt;

a record map of values with variable's name as key and `description` as directive's description.

#### fallback?

`string`

optional fallback value if a variable cannot be substituted.

### Returns

`string`

an interpolated new string from the template.

### Example

```js
const values = { foo: 42, bar: { value: "test" } };
const template = "${foo} is not ${bar.notfound}";

interpolate(template, values, "fallback"); // Expected result: "42 is not fallback",
```

---

## API


This section provides documentation of the GraphQL-Markdown API for NodeJS. For more details about each individual module, refer to the specific package documentation below.

## Packages

GraphQL-Markdown is organized into several packages:

- [@graphql-markdown/cli](/api/category/graphql-markdowncli/) - Command-line interface for generating documentation
- [@graphql-markdown/core](/api/category/graphql-markdowncore/) - Core functionality and base classes
- [@graphql-markdown/docusaurus](/api/category/graphql-markdowndocusaurus/) - Docusaurus plugin and MDX formatters
- [@graphql-markdown/graphql](/api/category/graphql-markdowngraphql/) - GraphQL schema utilities and helpers
- [@graphql-markdown/helpers](/api/category/graphql-markdownhelpers/) - Helper functions for documentation generation
- [@graphql-markdown/printer-legacy](/api/category/graphql-markdownprinter-legacy/) - Legacy markdown printer implementation
- [@graphql-markdown/utils](/api/category/graphql-markdownutils/) - Utility functions and helpers

## Installation

```bash
npm install @graphql-markdown/cli
# or with your preferred package manager
yarn add @graphql-markdown/cli
```

## Basic Usage

Using the CLI:

```bash
graphql-markdown --schema ./schema.graphql --root ./docs
```

For programmatic usage, you can use the CLI package:

```typescript

const config = {
  schema: "./schema.graphql",
  rootPath: "./docs",
};

await runGraphQLMarkdown(config);
```

## Contributing

This documentation is intended primarily for those interested in:

- Contributing to the GraphQL-Markdown codebase
- Developing custom documentation generators
- Extending the base functionality
- Understanding the internal architecture

---

## logger

Logger singleton module.

## LogLevel \{#loglevel\}

Defined in: index.ts:23

Log levels supported by the logger.

### Remarks

The logger supports standard console methods plus custom 'success' level
for framework-specific integrations like Docusaurus.

### Enumeration Members

#### debug \{#debug\}

```ts
debug: "debug";
```

Defined in: index.ts:24

#### error \{#error\}

```ts
error: "error";
```

Defined in: index.ts:25

#### info \{#info\}

```ts
info: "info";
```

Defined in: index.ts:26

#### log \{#log\}

```ts
log: "log";
```

Defined in: index.ts:27

#### success \{#success\}

```ts
success: "success";
```

Defined in: index.ts:28

#### warn \{#warn\}

```ts
warn: "warn";
```

Defined in: index.ts:29

---

## \_\_internal \{#\_\_internal\}

```ts
const __internal: object;
```

Defined in: index.ts:183

**`Internal`**

Internal helpers exported for testing purposes only.
Not part of the public API — do not use in application code.

### Type Declaration

#### hasLogMethod \{#haslogmethod\}

```ts
hasLogMethod: (instance, level) => instance is Record<string, (args: unknown[]) => unknown>;
```

Type guard to check if an object has a log method for a given level.

##### Parameters

###### instance

`unknown`

The object to check

###### level

\| `"debug"`
\| `"error"`
\| `"info"`
\| `"log"`
\| `"success"`
\| `"warn"`
\| [`LogLevel`](#loglevel)

The log level to verify

##### Returns

`instance is Record<string, (args: unknown[]) => unknown>`

`true` if the instance has a function at the given level, `false` otherwise

#### resolveLoggerInstance \{#resolveloggerinstance\}

```ts
resolveLoggerInstance: (instance) =>
  | Partial<Record<LogLevel, (...unknown) => void>>
  | undefined;
```

Resolve a logger instance from a module export.

##### Parameters

###### instance

`unknown`

The module export or object to resolve

##### Returns

\| `Partial`&lt;`Record`&lt;`LogLevel`, (...`unknown`) => `void`&gt;&gt;
\| `undefined`

The logger instance if found, or `undefined` if no valid logger is detected (the caller is responsible for falling back to `globalThis.console`)

##### Remarks

Handles various module export patterns:

- Direct logger instance: `{ info: () => {}, ... }`
- Default export: `{ default: { info: () => {}, ... } }`
- Named export: `{ logger: { info: () => {}, ... } }`

---

## log() \{#log-1\}

```ts
function log(message, level?): void;
```

Defined in: index.ts:168

Logs a message by calling the active logger instance.

### Parameters

#### message

`string`

a string to be logged.

#### level?

\| `"debug"`
\| `"error"`
\| `"info"`
\| `"log"`
\| `"success"`
\| `"warn"`
\| [`LogLevel`](#loglevel)

optional log level, `"info"` by default.

### Returns

`void`

### Remarks

If a log level is not supported by the logger instance, then it defaults to `"info"`.

### Example

```js

log("Info message"); // Expected console output "Info message"
```

---

## Logger() \{#logger\}

```ts
function Logger(moduleName?): Promise<void>;
```

Defined in: index.ts:111

Instantiate a logger module.
By default, the logger module uses `globalThis.console`

### Parameters

#### moduleName?

`string`

optional name of the logger package.

### Returns

`Promise`&lt;`void`&gt;

### Example

```js

log("Info message"); // Expected console output "Info message"

Logger("@docusaurus/logger");
log("Info message", "info"); // Expected Docusaurus log output "Info message"
```

---

## badge

Module for handling GraphQL type badges in MDX documentation.
Provides functionality to generate and format badges for different GraphQL types
and their properties like deprecation status, nullability, and relationships.

## CSS_BADGE_CLASSNAME \{#css_badge_classname\}

```ts
const CSS_BADGE_CLASSNAME: object;
```

Defined in: printer-legacy/src/badge.ts:32

### Type Declaration

#### DEPRECATED \{#deprecated\}

```ts
DEPRECATED: string = "DEPRECATED";
```

#### NON_NULL \{#non_null\}

```ts
NON_NULL: string = "NON_NULL";
```

#### RELATION \{#relation\}

```ts
RELATION: string = "RELATION";
```

---

## getTypeBadges() \{#gettypebadges\}

```ts
function getTypeBadges(type, groups?): Badge[];
```

Defined in: printer-legacy/src/badge.ts:44

Gets an array of badges for a given GraphQL type.

### Parameters

#### type

`unknown`

The GraphQL type to generate badges for

#### groups?

`Maybe`&lt;`Partial`&lt;`Record`&lt;`SchemaEntity`, `Record`&lt;`string`, `Maybe`&lt;`string`&gt;&gt;&gt;&gt;&gt;

Optional map of schema entities to their groups

### Returns

`Badge`[]

Array of Badge objects containing text and optional classnames

---

## printBadge() \{#printbadge\}

```ts
function printBadge(badge, options): MDXString;
```

Defined in: printer-legacy/src/badge.ts:97

Formats a single badge into MDX string format.

### Parameters

#### badge

`Badge`

The badge object containing text and optional classname

#### options

`PrintTypeOptions`

Options containing the formatter for badges

### Returns

`MDXString`

Formatted MDX string representation of the badge

---

## printBadges() \{#printbadges\}

```ts
function printBadges(type, options): string | MDXString;
```

Defined in: printer-legacy/src/badge.ts:119

Generates and formats all applicable badges for a GraphQL type.

### Parameters

#### type

`unknown`

The GraphQL type to generate badges for

#### options

`PrintTypeOptions`

Options for printing/formatting the badges

### Returns

`string` \| `MDXString`

Formatted MDX string containing all badges, or empty string if no badges or badges disabled

---

## code

Provides utility functions for generating code representations of GraphQL types
in Markdown format. This module handles the formatting of arguments and fields
with proper indentation and deprecation notices.

## printCodeArguments() \{#printcodearguments\}

```ts
function printCodeArguments(type, indentationLevel?): string;
```

Defined in: printer-legacy/src/code.ts:41

Generates a string representation of GraphQL arguments with proper formatting and indentation.

### Parameters

#### type

`unknown`

The GraphQL type object containing arguments to print

#### indentationLevel?

`number` = `1`

The level of indentation to apply (default: 1)

### Returns

`string`

A formatted string of arguments or an empty string if no arguments exist

### Example

```
printCodeArguments({ args: [{ name: 'id', type: 'ID!' }] })
// Returns:
// (
//   id: ID!
// )
```

---

## printCodeField() \{#printcodefield\}

```ts
function printCodeField(type, options?, indentationLevel?): string | MDXString;
```

Defined in: printer-legacy/src/code.ts:87

Generates a string representation of a GraphQL field including its arguments,
return type, and deprecation status.

### Parameters

#### type

`unknown`

The GraphQL field type object to print

#### options?

`PrintTypeOptions`

Optional configuration for printing the type

#### indentationLevel?

`number` = `0`

The level of indentation to apply (default: 0)

### Returns

`string` \| `MDXString`

A formatted string representing the field or an empty string if the field should not be printed

### Example

```
printCodeField({ name: 'user', type: 'User!', args: [{ name: 'id', type: 'ID!' }] })
// Returns: user(
//   id: ID!
// ): User!
```

---

## common

Common printer utility functions for handling descriptions, directives, and warnings.

## formatDescription() \{#formatdescription\}

```ts
function formatDescription(type, replacement?): string | MDXString;
```

Defined in: printer-legacy/src/common.ts:73

Formats a GraphQL type description or falls back to a default message.

### Parameters

#### type

`unknown`

GraphQL type to get description from

#### replacement?

`Maybe`&lt;`string`&gt; = `NO_DESCRIPTION_TEXT`

Optional fallback text if no description exists

### Returns

`string` \| `MDXString`

Formatted description string or MDX content

---

## printCustomDirectives() \{#printcustomdirectives\}

```ts
function printCustomDirectives(type, options?): string;
```

Defined in: printer-legacy/src/common.ts:33

Prints documentation for custom directives applied to a type.

### Parameters

#### type

`unknown`

GraphQL type to get directives from

#### options?

`PrintTypeOptions`

Printer configuration options

### Returns

`string`

Formatted directive documentation string

---

## printDeprecation() \{#printdeprecation\}

```ts
function printDeprecation(type, options): string;
```

Defined in: printer-legacy/src/common.ts:114

Prints deprecation information for a GraphQL type if it is deprecated.

### Parameters

#### type

`unknown`

The GraphQL type to check for deprecation

#### options

`PrintTypeOptions`

Configuration options for printing

### Returns

`string`

Formatted deprecation warning as MDX string, or empty string if not deprecated

---

## printDescription() \{#printdescription\}

```ts
function printDescription(type, options, noText?): string | MDXString;
```

Defined in: printer-legacy/src/common.ts:140

Prints the complete description for a GraphQL type, including deprecation warnings and custom directives.

### Parameters

#### type

`unknown`

The GraphQL type to document

#### options

`PrintTypeOptions`

Configuration options for printing

#### noText?

`string`

Optional text to display when no description exists

### Returns

`string` \| `MDXString`

Combined description, deprecation notices, and custom directives as MDX content

---

## printWarning() \{#printwarning\}

```ts
function printWarning(warningConfig, options): string;
```

Defined in: printer-legacy/src/common.ts:93

Generates a warning message block in MDX format.

### Parameters

#### warningConfig

Warning configuration object with `text` and optional `title` properties

##### text?

`string`

##### title?

`string`

#### options

`PrintTypeOptions`

Configuration options for printing

### Returns

`string`

Formatted warning message as MDX string

---

## options

## SectionLevels \{#sectionlevels\}

Defined in: printer-legacy/src/const/options.ts:22

### Enumeration Members

#### LEVEL \{#level\}

```ts
LEVEL: "#";
```

Defined in: printer-legacy/src/const/options.ts:24

#### NONE \{#none\}

```ts
NONE: "";
```

Defined in: printer-legacy/src/const/options.ts:23

---

## TypeHierarchy \{#typehierarchy\}

Defined in: printer-legacy/src/const/options.ts:16

### Enumeration Members

#### API \{#api\}

```ts
API: "api";
```

Defined in: printer-legacy/src/const/options.ts:17

#### ENTITY \{#entity\}

```ts
ENTITY: "entity";
```

Defined in: printer-legacy/src/const/options.ts:18

#### FLAT \{#flat\}

```ts
FLAT: "flat";
```

Defined in: printer-legacy/src/const/options.ts:19

---

## DEFAULT_OPTIONS \{#default_options\}

```ts
const DEFAULT_OPTIONS: Required<
  Omit<
    PrintTypeOptions,
    | "afterDiffCheckHook"
    | "afterGenerateIndexMetafileHook"
    | "afterRenderHomepageHook"
    | "afterRenderRootTypesHook"
    | "afterRenderTypeEntitiesHook"
    | "afterSchemaLoadHook"
    | "beforeDiffCheckHook"
    | "beforeGenerateIndexMetafileHook"
    | "beforeRenderHomepageHook"
    | "beforeRenderRootTypesHook"
    | "beforeRenderTypeEntitiesHook"
    | "beforeSchemaLoadHook"
    | "collapsible"
    | "exampleSection"
    | "formatCategoryFolderName"
    | "groups"
    | "level"
    | "meta"
    | "onlyDocDirectives"
    | "parentType"
    | "schema"
    | "skipDocDirectives"
  >
> &
  object;
```

Defined in: printer-legacy/src/const/options.ts:54

Clean runtime options passed through the printer.

Deprecated section toggles are excluded and handled via backward-compat paths.

### Type Declaration

#### collapsible

```ts
collapsible: Maybe<CollapsibleOption>;
```

#### exampleSection

```ts
exampleSection: PrintTypeOptions["exampleSection"];
```

#### groups

```ts
groups: Maybe<SchemaEntitiesGroupMap>;
```

#### level

```ts
level: Maybe<SectionLevelValue>;
```

#### onlyDocDirectives

```ts
onlyDocDirectives: GraphQLDirective[];
```

#### parentType

```ts
parentType: Maybe<string>;
```

#### schema

```ts
schema: Maybe<GraphQLSchema>;
```

#### skipDocDirectives

```ts
skipDocDirectives: GraphQLDirective[];
```

---

## PRINT_TYPE_DEFAULT_DEPRECATED_OPTIONS \{#print_type_default_deprecated_options\}

```ts
const PRINT_TYPE_DEFAULT_DEPRECATED_OPTIONS: object;
```

Defined in: printer-legacy/src/const/options.ts:27

### Type Declaration

#### codeSection \{#codesection\}

```ts
codeSection: true;
```

#### exampleSection \{#examplesection\}

```ts
exampleSection: false;
```

#### relatedTypeSection \{#relatedtypesection\}

```ts
relatedTypeSection: true;
```

---

## PRINT_TYPE_DEFAULT_OPTIONS \{#print_type_default_options\}

```ts
const PRINT_TYPE_DEFAULT_OPTIONS: Required<
  Omit<PrinterConfigPrintTypeOptions, "exampleSection">
> &
  object;
```

Defined in: printer-legacy/src/const/options.ts:36

### Type Declaration

#### exampleSection

```ts
exampleSection: PrintTypeOptions["exampleSection"];
```

---

## strings

String constants and helpers shared by the legacy printer when composing
Markdown fragments for GraphQL schemas.

## DEPRECATED \{#deprecated\}

```ts
const DEPRECATED: "deprecated";
```

Defined in: printer-legacy/src/const/strings.ts:36

Label used when a schema element is flagged as deprecated.

---

## FRONT_MATTER_DELIMITER \{#front_matter_delimiter\}

```ts
const FRONT_MATTER_DELIMITER: "---";
```

Defined in: utils/dist/markdown.d.ts:17

Frontmatter delimiter for YAML frontmatter blocks.

---

## GRAPHQL \{#graphql\}

```ts
const GRAPHQL: "graphql";
```

Defined in: printer-legacy/src/const/strings.ts:42

Short identifier for the GraphQL language tag used in fenced blocks.

---

## MARKDOWN_CODE_INDENTATION \{#markdown_code_indentation\}

```ts
const MARKDOWN_CODE_INDENTATION: "  ";
```

Defined in: utils/dist/markdown.d.ts:25

Standard indentation for code blocks (2 spaces).

---

## MARKDOWN_CODE_SNIPPET \{#markdown_code_snippet\}

```ts
const MARKDOWN_CODE_SNIPPET: "``";
```

Defined in: utils/dist/markdown.d.ts:21

Code snippet delimiter for fenced code blocks.

---

## MARKDOWN_EOC \{#markdown_eoc\}

```ts
const MARKDOWN_EOC: "\n``\n";
```

Defined in: printer-legacy/src/const/strings.ts:48

Helper for inserting the code-block end delimiter in generated Markdown.

---

## MARKDOWN_EOL \{#markdown_eol\}

```ts
const MARKDOWN_EOL: "\n";
```

Defined in: utils/dist/markdown.d.ts:9

End of line character for Markdown.

---

## MARKDOWN_EOP \{#markdown_eop\}

```ts
const MARKDOWN_EOP: string;
```

Defined in: utils/dist/markdown.d.ts:13

End of paragraph (double newline) for Markdown.

---

## MARKDOWN_SOC \{#markdown_soc\}

```ts
const MARKDOWN_SOC: "\n``graphql\n";
```

Defined in: printer-legacy/src/const/strings.ts:52

Helper for inserting the code-block start delimiter targeting GraphQL syntax.

---

## NO_DESCRIPTION_TEXT \{#no_description_text\}

```ts
const NO_DESCRIPTION_TEXT: "No description";
```

Defined in: printer-legacy/src/const/strings.ts:45

Default placeholder when no schema description is provided.

---

## NON_NULL \{#non_null\}

```ts
const NON_NULL: "non-null";
```

Defined in: printer-legacy/src/const/strings.ts:39

Copy fragment describing a non-null GraphQL modifier.

---

## ROOT_TYPE_LOCALE \{#root_type_locale\}

```ts
const ROOT_TYPE_LOCALE: RootTypeLocale;
```

Defined in: printer-legacy/src/const/strings.ts:21

Human-readable labels for each GraphQL root type used when rendering copy or badges.

---

## directive(Printer-legacy)

Provides utilities for handling and printing GraphQL directives in Markdown format

## getCustomDirectiveResolver() \{#getcustomdirectiveresolver\}

```ts
function getCustomDirectiveResolver(
  resolver,
  type,
  constDirectiveOption,
  fallback?,
): Maybe<string>;
```

Defined in: printer-legacy/src/directive.ts:31

Resolves a custom directive using the provided resolver function

### Parameters

#### resolver

`CustomDirectiveResolver`

The resolver function name to execute

#### type

`unknown`

The GraphQL type to resolve the directive for

#### constDirectiveOption

`CustomDirectiveMapItem`

The directive configuration options

#### fallback?

`Maybe`&lt;`string`&gt;

Optional fallback value if resolution fails

### Returns

`Maybe`&lt;`string`&gt;

The resolved directive value or `fallback`/`undefined`

---

## getCustomTags() \{#getcustomtags\}

```ts
function getCustomTags(type, options): Badge[];
```

Defined in: printer-legacy/src/directive.ts:125

Extracts custom tags from directives for a given type

### Parameters

#### type

`unknown`

The GraphQL type to get tags for

#### options

`PrintTypeOptions`

General printing options

### Returns

`Badge`[]

Array of badge configurations from directive tags

---

## printCustomDirective() \{#printcustomdirective\}

```ts
function printCustomDirective(
  type,
  constDirectiveOption,
  options,
): Maybe<string>;
```

Defined in: printer-legacy/src/directive.ts:57

Prints a custom directive as a Markdown string

### Parameters

#### type

`unknown`

The GraphQL type to print the directive for

#### constDirectiveOption

`CustomDirectiveMapItem`

The directive configuration options

#### options

`PrintTypeOptions`

General printing options

### Returns

`Maybe`&lt;`string`&gt;

Formatted Markdown string for the directive or `undefined`

---

## printCustomDirectives() \{#printcustomdirectives\}

```ts
function printCustomDirectives(type, options): Maybe<PageSection>;
```

Defined in: printer-legacy/src/directive.ts:85

Prints all custom directives for a type as a Markdown section

### Parameters

#### type

`unknown`

The GraphQL type to print directives for

#### options

`PrintTypeOptions`

General printing options

### Returns

`Maybe`&lt;[`PageSection`](events.md#pagesection)&gt;

A "Directives" PageSection, or undefined when no directives are printable

---

## printCustomTags() \{#printcustomtags\}

```ts
function printCustomTags(type, options): string | MDXString;
```

Defined in: printer-legacy/src/directive.ts:157

Prints custom directive tags as Markdown badges

### Parameters

#### type

`unknown`

The GraphQL type to print tags for

#### options

`PrintTypeOptions`

General printing options

### Returns

`string` \| `MDXString`

Formatted Markdown string of badges or empty string

---

## events(Printer-legacy)

Print type event classes.

Event classes for print operations that allow handlers to modify the generated output.

## Events

### BeforeComposePageTypeEvent \{#beforecomposepagetypeevent\}

Defined in: printer-legacy/src/events.ts:114

Event emitted before composing page sections for a GraphQL type.

This event fires after section content is generated and before sections are joined into final output.
The `output` property contains an array of content section keys that will be included in the final page,
in addition to fixed header sections (`header`, `metatags`, `mdxDeclaration`) which are managed separately
by the printer and always prepended. Handlers can reorder, filter, or append to this array to control the
structure of the content portion of the page.

#### Example

```typescript
events.on(
  PrintTypeEvents.BEFORE_COMPOSE_PAGE_TYPE,
  (event: BeforeComposePageTypeEvent) => {
    // Move relations section before metadata
    const idx = event.output.indexOf("relations");
    if (idx > -1) {
      event.output.splice(idx, 1);
      const metaidx = event.output.indexOf("metadata");
      event.output.splice(metaidx, 0, "relations");
    }
  },
);
```

#### Extends

- [`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent)&lt;[`ComposePageTypeEventData`](#composepagetypeeventdata), keyof [`PageSections`](#pagesections)[]&gt;

#### Constructors

##### Constructor

```ts
new BeforeComposePageTypeEvent(
   data,
   initialOutput,
   options?): BeforeComposePageTypeEvent;
```

Defined in: printer-legacy/src/events.ts:118

###### Parameters

###### data

[`ComposePageTypeEventData`](#composepagetypeeventdata)

###### initialOutput

keyof [`PageSections`](#pagesections)[]

###### options?

[`CancellableEventOptions`](../utils/events.md#cancellableeventoptions)

###### Returns

[`BeforeComposePageTypeEvent`](#beforecomposepagetypeevent)

###### Overrides

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`constructor`](../utils/events.md#constructor-2)

#### Properties

##### data \{#data\}

```ts
readonly data: ComposePageTypeEventData;
```

Defined in: utils/dist/events.d.ts:111

Read-only event data payload.

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`data`](../utils/events.md#data-1)

##### output \{#output\}

```ts
output: keyof PageSections[];
```

Defined in: utils/dist/events.d.ts:127

The generated output.
Handlers can modify this property to change the final result.

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`output`](../utils/events.md#output)

#### Accessors

##### defaultAction \{#defaultaction\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: utils/dist/events.d.ts:78

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`defaultAction`](../utils/events.md#defaultaction-2)

##### defaultPrevented \{#defaultprevented\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: utils/dist/events.d.ts:70

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: utils/dist/events.d.ts:82

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`defaultPrevented`](../utils/events.md#defaultprevented-2)

##### propagationStopped \{#propagationstopped\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: utils/dist/events.d.ts:74

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: utils/dist/events.d.ts:86

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`propagationStopped`](../utils/events.md#propagationstopped-2)

#### Methods

##### preventDefault() \{#preventdefault\}

```ts
preventDefault(): void;
```

Defined in: utils/dist/events.d.ts:91

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`preventDefault`](../utils/events.md#preventdefault-2)

##### runDefaultAction() \{#rundefaultaction\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: utils/dist/events.d.ts:100

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`runDefaultAction`](../utils/events.md#rundefaultaction-2)

##### stopPropagation() \{#stoppropagation\}

```ts
stopPropagation(): void;
```

Defined in: utils/dist/events.d.ts:96

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`stopPropagation`](../utils/events.md#stoppropagation-2)

---

### PrintCodeEvent \{#printcodeevent\}

Defined in: printer-legacy/src/events.ts:48

Event emitted around code block generation for a GraphQL type.

The `output` property is mutable, allowing event handlers to modify
the generated code before it's included in the documentation.

#### Example

```typescript
events.on(PrintTypeEvents.AFTER_PRINT_CODE, (event: PrintCodeEvent) => {
  // Add a comment to all generated code
  event.output = `# Auto-generated\n${event.output}`;
});
```

#### Extends

- [`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent)&lt;[`PrintCodeEventData`](#printcodeeventdata-1), `string`&gt;

#### Implements

- `IPrintCodeEvent`

#### Constructors

##### Constructor

```ts
new PrintCodeEvent(
   data,
   initialOutput,
   options?): PrintCodeEvent;
```

Defined in: printer-legacy/src/events.ts:52

###### Parameters

###### data

[`PrintCodeEventData`](#printcodeeventdata-1)

###### initialOutput

`string`

###### options?

[`CancellableEventOptions`](../utils/events.md#cancellableeventoptions)

###### Returns

[`PrintCodeEvent`](#printcodeevent)

###### Overrides

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`constructor`](../utils/events.md#constructor-2)

#### Properties

##### data \{#data-1\}

```ts
readonly data: PrintCodeEventData;
```

Defined in: utils/dist/events.d.ts:111

Read-only event data payload.

###### Implementation of

```ts
IPrintCodeEvent.data;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`data`](../utils/events.md#data-1)

##### output \{#output-1\}

```ts
output: string;
```

Defined in: utils/dist/events.d.ts:127

The generated output.
Handlers can modify this property to change the final result.

###### Implementation of

```ts
IPrintCodeEvent.output;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`output`](../utils/events.md#output)

#### Accessors

##### defaultAction \{#defaultaction-1\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: utils/dist/events.d.ts:78

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Implementation of

```ts
IPrintCodeEvent.defaultAction;
```

###### Inherited from

[`PrintTypeEvent`](#printtypeevent).[`defaultAction`](#defaultaction-2)

##### defaultPrevented \{#defaultprevented-1\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: utils/dist/events.d.ts:70

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: utils/dist/events.d.ts:82

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Implementation of

```ts
IPrintCodeEvent.defaultPrevented;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`defaultPrevented`](../utils/events.md#defaultprevented-2)

##### propagationStopped \{#propagationstopped-1\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: utils/dist/events.d.ts:74

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: utils/dist/events.d.ts:86

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Implementation of

```ts
IPrintCodeEvent.propagationStopped;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`propagationStopped`](../utils/events.md#propagationstopped-2)

#### Methods

##### preventDefault() \{#preventdefault-1\}

```ts
preventDefault(): void;
```

Defined in: utils/dist/events.d.ts:91

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Implementation of

```ts
IPrintCodeEvent.preventDefault;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`preventDefault`](../utils/events.md#preventdefault-2)

##### runDefaultAction() \{#rundefaultaction-1\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: utils/dist/events.d.ts:100

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Implementation of

```ts
IPrintCodeEvent.runDefaultAction;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`runDefaultAction`](../utils/events.md#rundefaultaction-2)

##### stopPropagation() \{#stoppropagation-1\}

```ts
stopPropagation(): void;
```

Defined in: utils/dist/events.d.ts:96

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Implementation of

```ts
IPrintCodeEvent.stopPropagation;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`stopPropagation`](../utils/events.md#stoppropagation-2)

---

### PrintTypeEvent \{#printtypeevent\}

Defined in: printer-legacy/src/events.ts:77

Event emitted around full documentation generation for a GraphQL type.

The `output` property is mutable, allowing event handlers to modify
the complete generated documentation.

#### Example

```typescript
events.on(PrintTypeEvents.AFTER_PRINT_TYPE, (event: PrintTypeEvent) => {
  // Add a footer to all type documentation
  event.output = `${event.output}\n\n---\nGenerated by GraphQL-Markdown`;
});
```

#### Extends

- [`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent)&lt;[`PrintTypeEventData`](#printtypeeventdata-1), `Maybe`&lt;`MDXString`&gt;&gt;

#### Implements

- `IPrintTypeEvent`

#### Constructors

##### Constructor

```ts
new PrintTypeEvent(
   data,
   initialOutput,
   options?): PrintTypeEvent;
```

Defined in: printer-legacy/src/events.ts:81

###### Parameters

###### data

[`PrintTypeEventData`](#printtypeeventdata-1)

###### initialOutput

`Maybe`&lt;`MDXString`&gt;

###### options?

[`CancellableEventOptions`](../utils/events.md#cancellableeventoptions)

###### Returns

[`PrintTypeEvent`](#printtypeevent)

###### Overrides

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`constructor`](../utils/events.md#constructor-2)

#### Properties

##### data \{#data-2\}

```ts
readonly data: PrintTypeEventData;
```

Defined in: utils/dist/events.d.ts:111

Read-only event data payload.

###### Implementation of

```ts
IPrintTypeEvent.data;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`data`](../utils/events.md#data-1)

##### output \{#output-2\}

```ts
output: Maybe;
```

Defined in: utils/dist/events.d.ts:127

The generated output.
Handlers can modify this property to change the final result.

###### Implementation of

```ts
IPrintTypeEvent.output;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`output`](../utils/events.md#output)

#### Accessors

##### defaultAction \{#defaultaction-2\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: utils/dist/events.d.ts:78

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Implementation of

```ts
IPrintTypeEvent.defaultAction;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`defaultAction`](../utils/events.md#defaultaction-2)

##### defaultPrevented \{#defaultprevented-2\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: utils/dist/events.d.ts:70

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: utils/dist/events.d.ts:82

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Implementation of

```ts
IPrintTypeEvent.defaultPrevented;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`defaultPrevented`](../utils/events.md#defaultprevented-2)

##### propagationStopped \{#propagationstopped-2\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: utils/dist/events.d.ts:74

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: utils/dist/events.d.ts:86

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Implementation of

```ts
IPrintTypeEvent.propagationStopped;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`propagationStopped`](../utils/events.md#propagationstopped-2)

#### Methods

##### preventDefault() \{#preventdefault-2\}

```ts
preventDefault(): void;
```

Defined in: utils/dist/events.d.ts:91

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Implementation of

```ts
IPrintTypeEvent.preventDefault;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`preventDefault`](../utils/events.md#preventdefault-2)

##### runDefaultAction() \{#rundefaultaction-2\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: utils/dist/events.d.ts:100

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Implementation of

```ts
IPrintTypeEvent.runDefaultAction;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`runDefaultAction`](../utils/events.md#rundefaultaction-2)

##### stopPropagation() \{#stoppropagation-2\}

```ts
stopPropagation(): void;
```

Defined in: utils/dist/events.d.ts:96

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Implementation of

```ts
IPrintTypeEvent.stopPropagation;
```

###### Inherited from

[`DataOutputEvent`](../utils/events.md#abstract-dataoutputevent).[`stopPropagation`](../utils/events.md#stoppropagation-2)

## Other

### ComposePageTypeEventData \{#composepagetypeeventdata\}

Defined in: types/src/printer.d.ts:114

Data payload for compose page type events.

#### Properties

##### name \{#name\}

```ts
readonly name: Maybe<string>;
```

Defined in: types/src/printer.d.ts:118

The name identifier for the type

##### options \{#options\}

```ts
readonly options: PrintTypeOptions;
```

Defined in: types/src/printer.d.ts:120

The print options in effect

##### sections \{#sections\}

```ts
readonly sections: PageSections;
```

Defined in: types/src/printer.d.ts:122

The map of all page sections (mutable in BEFORE event)

##### type \{#type\}

```ts
readonly type: unknown;
```

Defined in: types/src/printer.d.ts:116

The GraphQL type being composed

---

### PageSection \{#pagesection\}

Defined in: types/src/printer.d.ts:24

Represents a single section of a page with optional title and content.

#### Properties

##### content? \{#content\}

```ts
optional content?:
  | string
  | MDXString
  | PageSection
  | PageSection[];
```

Defined in: types/src/printer.d.ts:30

The section content

##### level? \{#level\}

```ts
optional level?: number;
```

Defined in: types/src/printer.d.ts:28

Optional section level for hierarchical structuring

##### title? \{#title\}

```ts
optional title?: string | MDXString;
```

Defined in: types/src/printer.d.ts:26

Optional title/heading for the section

---

### PageSections \{#pagesections\}

Defined in: types/src/printer.d.ts:36

Map of all available sections in a type page.

#### Indexable

```ts
[key: string]: Maybe<PageSection | PageHeader>
```

Additional custom sections can be added by event handlers

#### Properties

##### code? \{#code\}

```ts
optional code?: PageSection;
```

Defined in: types/src/printer.d.ts:50

GraphQL code block

##### customDirectives? \{#customdirectives\}

```ts
optional customDirectives?: PageSection;
```

Defined in: types/src/printer.d.ts:52

Custom directives

##### description? \{#description\}

```ts
optional description?: PageSection;
```

Defined in: types/src/printer.d.ts:48

Type description from GraphQL comments

##### example? \{#example\}

```ts
optional example?: PageSection;
```

Defined in: types/src/printer.d.ts:56

Usage examples

##### header? \{#header\}

```ts
optional header?: PageHeader;
```

Defined in: types/src/printer.d.ts:40

YAML frontmatter or top-level heading

##### mdxDeclaration? \{#mdxdeclaration\}

```ts
optional mdxDeclaration?: PageHeader;
```

Defined in: types/src/printer.d.ts:44

MDX import declarations

##### metadata? \{#metadata\}

```ts
optional metadata?: PageSection;
```

Defined in: types/src/printer.d.ts:54

Type metadata (fields, arguments, etc.)

##### metatags? \{#metatags\}

```ts
optional metatags?: PageHeader;
```

Defined in: types/src/printer.d.ts:42

HTML meta tags

##### relations? \{#relations\}

```ts
optional relations?: PageSection;
```

Defined in: types/src/printer.d.ts:58

Related types

##### tags? \{#tags\}

```ts
optional tags?: PageSection;
```

Defined in: types/src/printer.d.ts:46

Custom tags (e.g., @deprecated)

---

### PrintCodeEventData \{#printcodeeventdata-1\}

Defined in: types/src/printer.d.ts:64

Data payload for print code events.

#### Properties

##### options \{#options-1\}

```ts
readonly options: PrintTypeOptions;
```

Defined in: types/src/printer.d.ts:70

The print options in effect

##### type \{#type-1\}

```ts
readonly type: unknown;
```

Defined in: types/src/printer.d.ts:66

The GraphQL type being printed

##### typeName \{#typename\}

```ts
readonly typeName: string;
```

Defined in: types/src/printer.d.ts:68

The name of the type

---

### PrintTypeEventData \{#printtypeeventdata-1\}

Defined in: types/src/printer.d.ts:76

Data payload for print type events.

#### Properties

##### name \{#name-1\}

```ts
readonly name: Maybe<string>;
```

Defined in: types/src/printer.d.ts:80

The name identifier for the type

##### options \{#options-2\}

```ts
readonly options: PrintTypeOptions;
```

Defined in: types/src/printer.d.ts:82

The print options in effect

##### type \{#type-2\}

```ts
readonly type: unknown;
```

Defined in: types/src/printer.d.ts:78

The GraphQL type being printed

---

## example

Module providing utilities for handling GraphQL example directives and printing example values.

## getDirectiveExampleOption() \{#getdirectiveexampleoption\}

```ts
function getDirectiveExampleOption(options): Maybe<TypeDirectiveExample>;
```

Defined in: printer-legacy/src/example.ts:44

Retrieves directive example options from the provided print type options.

### Parameters

#### options

`PrintTypeOptions`

Configuration options

### Returns

`Maybe`&lt;`TypeDirectiveExample`&gt;

The directive example configuration if valid, otherwise `undefined`

---

## printExample() \{#printexample\}

```ts
function printExample(type, options): Maybe<string>;
```

Defined in: printer-legacy/src/example.ts:252

Prints an example value for a given GraphQL type or operation.

### Parameters

#### type

`unknown`

The GraphQL type or operation to generate an example for

#### options

`PrintTypeOptions`

Configuration options for printing the example

### Returns

`Maybe`&lt;`string`&gt;

Stringified example if available, otherwise `undefined`

### Example

```ts
const example = printExample(type, { schema, exampleSection });
if (example) {
  console.log(example);
}
```

---

## format-helpers

Format event helpers for printer-legacy.

This module provides helper functions to emit MDX format events and handle
fallback to default formatters when no custom handlers are registered.

## formatMDXAdmonition() \{#formatmdxadmonition\}

```ts
function formatMDXAdmonition(__namedParameters, _meta): MDXString;
```

Defined in: printer-legacy/src/format-helpers.ts:38

Default admonition formatter.

### Parameters

#### \_\_namedParameters

`AdmonitionType`

#### \_meta

`Maybe`&lt;`MetaInfo`&gt;

### Returns

`MDXString`

---

## formatMDXBadge() \{#formatmdxbadge\}

```ts
function formatMDXBadge(badge): MDXString;
```

Defined in: printer-legacy/src/format-helpers.ts:31

Default badge formatter.

### Parameters

#### badge

`Badge`

### Returns

`MDXString`

---

## formatMDXBullet() \{#formatmdxbullet\}

```ts
function formatMDXBullet(text?): MDXString;
```

Defined in: printer-legacy/src/format-helpers.ts:48

Default bullet formatter.

### Parameters

#### text?

`string` = `""`

### Returns

`MDXString`

---

## formatMDXDetails() \{#formatmdxdetails\}

```ts
function formatMDXDetails(__namedParameters): MDXString;
```

Defined in: printer-legacy/src/format-helpers.ts:64

Default details formatter.

The returned string **must** contain a `\r` (carriage return) character as a
delimiter between the opening part (ending after `</summary>`) and the
closing part (starting before `</details>`). `printSection` calls
`result.split('\r')` to obtain `[openSection, closeSection]`; without this
delimiter the closing tag is lost and items are rendered outside the
collapsible element.

Custom implementations of `formatMDXDetails` must follow the same contract.

### Parameters

#### \_\_namedParameters

`CollapsibleOption`

### Returns

`MDXString`

---

## formatMDXFrontmatter() \{#formatmdxfrontmatter\}

```ts
function formatMDXFrontmatter(_props, formatted): MDXString;
```

Defined in: printer-legacy/src/format-helpers.ts:73

Default frontmatter formatter.

### Parameters

#### \_props

`Maybe`&lt;`FrontMatterOptions`&gt;

#### formatted

`Maybe`&lt;`string`[]&gt;

### Returns

`MDXString`

---

## formatMDXLink() \{#formatmdxlink\}

```ts
function formatMDXLink(link): TypeLink;
```

Defined in: printer-legacy/src/format-helpers.ts:87

Default link formatter.

### Parameters

#### link

`TypeLink`

### Returns

`TypeLink`

---

## formatMDXNameEntity() \{#formatmdxnameentity\}

```ts
function formatMDXNameEntity(name, parentType?): MDXString;
```

Defined in: printer-legacy/src/format-helpers.ts:94

Default name entity formatter.

### Parameters

#### name

`string`

#### parentType?

`Maybe`&lt;`string`&gt;

### Returns

`MDXString`

---

## formatMDXSpecifiedByLink() \{#formatmdxspecifiedbylink\}

```ts
function formatMDXSpecifiedByLink(url): MDXString;
```

Defined in: printer-legacy/src/format-helpers.ts:107

Default specified-by link formatter.

### Parameters

#### url

`string`

### Returns

`MDXString`

---

## formatter(Printer-legacy)

Formatter factories for GraphQL documentation output.

Provides factory functions to create formatters for different output targets.
The default formatter produces HTML-like markup suitable for most Markdown processors.

## createDefaultFormatter() \{#createdefaultformatter\}

```ts
function createDefaultFormatter(): Formatter;
```

Defined in: printer-legacy/src/formatter.ts:45

Creates a default formatter for documentation output.

The default formatter produces HTML-like markup with CSS classes
that can be styled with custom CSS. This is suitable for most
Markdown processors that support inline HTML.

### Returns

`Formatter`

A complete Formatter implementation

### Example

```typescript

const formatter = createDefaultFormatter();
const badge = formatter.formatMDXBadge({ text: "Required" });
```

---

## frontmatter

Module for handling frontmatter generation in Markdown documents.
Provides utilities for formatting and printing frontmatter content.

## printFrontMatter() \{#printfrontmatter\}

```ts
function printFrontMatter(title, props, options): string;
```

Defined in: printer-legacy/src/frontmatter.ts:21

Generates a formatted frontmatter string for Markdown/MDX documents.

### Parameters

#### title

`string`

The title to be included in the frontmatter

#### props

`Maybe`&lt;`FrontMatterOptions`&gt;

Additional frontmatter properties to be included

#### options

`PrintTypeOptions`

Configuration options for printing

### Returns

`string`

Formatted frontmatter string, or empty string if formatting is disabled

---

## directive(Graphql)

Module for handling GraphQL directive printing and formatting.
Provides utilities to generate string representations of GraphQL directives
including their metadata, arguments, and locations.

## printCodeDirective() \{#printcodedirective\}

```ts
function printCodeDirective(type, options?): string;
```

Defined in: printer-legacy/src/graphql/directive.ts:67

Generates a string representation of a complete GraphQL directive definition.

### Parameters

#### type

`GraphQLDirective`

The GraphQL directive to process

#### options?

`PrintDirectiveOptions`

Configuration options for printing the directive (optional)

### Returns

`string`

A formatted string containing the complete directive definition

---

## printDirectiveMetadata() \{#printdirectivemetadata\}

```ts
function printDirectiveMetadata(type, options): Maybe<PageSection>;
```

Defined in: printer-legacy/src/graphql/directive.ts:49

Prints metadata information for a GraphQL directive, focusing on its arguments.

### Parameters

#### type

`GraphQLDirective`

The GraphQL directive to process

#### options

`PrintDirectiveOptions`

Configuration options for printing directive metadata

### Returns

`Maybe`&lt;[`PageSection`](../events.md#pagesection)&gt;

An "Arguments" PageSection, or undefined when no arguments are available

---

## enum

Provides utilities for printing GraphQL enum types to Markdown/MDX format

## printCodeEnum() \{#printcodeenum\}

```ts
function printCodeEnum(type, options?): string;
```

Defined in: printer-legacy/src/graphql/enum.ts:47

Generates a GraphQL SDL code block for an enum type.

### Parameters

#### type

`unknown`

The GraphQL enum type to process

#### options?

`PrintTypeOptions`

Optional printing options that control directive handling

### Returns

`string`

A string containing the enum type definition in GraphQL SDL, or empty string if type is not an enum

---

## printEnumMetadata() \{#printenummetadata\}

```ts
function printEnumMetadata(type, options): Maybe<PageSection>;
```

Defined in: printer-legacy/src/graphql/enum.ts:29

Prints the metadata section for a GraphQL enum type.

### Parameters

#### type

`unknown`

The GraphQL enum type to process

#### options

`PrintTypeOptions`

Options for printing the type

### Returns

`Maybe`&lt;[`PageSection`](../events.md#pagesection)&gt;

A "Values" PageSection, or undefined when `type` is not an enum

---

## input

Legacy printer helpers for rendering GraphQL input types.

## printCodeInput() \{#printcodeinput\}

```ts
function printCodeInput(type, options): string;
```

Defined in: printer-legacy/src/graphql/input.ts:20

Renders the Markdown code snippet for a GraphQL `input` type by delegating
to the generic object printer while forcing the `input` kind.

### Parameters

#### type

`unknown`

The GraphQL input definition or SDL node to print.

#### options

`PrintTypeOptions`

Printer options controlling headings, examples, and badges.

### Returns

`string`

Markdown code block representing the input signature.

---

## interface

Contains utilities for printing GraphQL interface types as Markdown documentation.

## printCodeInterface() \{#printcodeinterface\}

```ts
function printCodeInterface(type, options): string;
```

Defined in: printer-legacy/src/graphql/interface.ts:23

Generates a code block representation of a GraphQL interface type.

### Parameters

#### type

`unknown`

The GraphQL interface type to print

#### options

`PrintTypeOptions`

Configuration options for printing the type

### Returns

`string`

A string containing the Markdown code block representation

---

## object

GraphQL Object Type printing utilities

## printCodeObject() \{#printcodeobject\}

```ts
function printCodeObject(type, options): string;
```

Defined in: printer-legacy/src/graphql/object.ts:108

Prints a GraphQL object type definition as a code block

### Parameters

#### type

`unknown`

The GraphQL type object to process

#### options

`PrintTypeOptions`

Printing options

### Returns

`string`

GraphQL object type definition as a code block string

---

## printCodeType() \{#printcodetype\}

```ts
function printCodeType(type, entity, options): string;
```

Defined in: printer-legacy/src/graphql/object.ts:68

Prints the GraphQL type definition as a code block

### Parameters

#### type

`unknown`

The GraphQL type object to process

#### entity

`string`

The entity type identifier (e.g., "type", "interface")

#### options

`PrintTypeOptions`

Printing options

### Returns

`string`

GraphQL type definition as a code block string

---

## printObjectMetadata() \{#printobjectmetadata\}

```ts
function printObjectMetadata(type, options): Maybe<PageSection[]>;
```

Defined in: printer-legacy/src/graphql/object.ts:46

Prints the complete metadata section for a GraphQL object type

### Parameters

#### type

`unknown`

The GraphQL type object to process

#### options

`PrintTypeOptions`

Printing options

### Returns

`Maybe`&lt;[`PageSection`](../events.md#pagesection)[]&gt;

Ordered metadata sections for fields and interfaces

---

## operation

Module for handling GraphQL operation printing functionality.
Provides utilities to print operation types, metadata, and code representations.

## printCodeOperation() \{#printcodeoperation\}

```ts
function printCodeOperation(type, options?): string | MDXString;
```

Defined in: printer-legacy/src/graphql/operation.ts:94

Prints the code representation of an operation.

### Parameters

#### type

`unknown`

#### options?

`PrintTypeOptions`

### Returns

`string` \| `MDXString`

---

## printOperationMetadata() \{#printoperationmetadata\}

```ts
function printOperationMetadata(type, options): Maybe<PageSection[]>;
```

Defined in: printer-legacy/src/graphql/operation.ts:45

Prints the operation metadata including arguments and type information.

### Parameters

#### type

`unknown`

The operation type to print metadata for

#### options

`PrintTypeOptions`

Print type options for customizing output

### Returns

`Maybe`&lt;[`PageSection`](../events.md#pagesection)[]&gt;

Ordered operation metadata sections, or undefined when `type` is not an operation

---

## printOperationType() \{#printoperationtype\}

```ts
function printOperationType(type, options): Maybe<PageSection>;
```

Defined in: printer-legacy/src/graphql/operation.ts:24

Prints the operation type information.

### Parameters

#### type

`unknown`

The operation type to print

#### options

`PrintTypeOptions`

Print type options for customizing output

### Returns

`Maybe`&lt;[`PageSection`](../events.md#pagesection)&gt;

A "Type" PageSection, or undefined when `type` is not an operation

---

## scalar

Provides utility functions for handling GraphQL scalar types in markdown generation.

## printCodeScalar() \{#printcodescalar\}

```ts
function printCodeScalar(type, options?): string;
```

Defined in: printer-legacy/src/graphql/scalar.ts:60

Generates the GraphQL SDL representation of a scalar type.

### Parameters

#### type

`unknown`

The GraphQL scalar type object

#### options?

`PrintTypeOptions`

Options for printing type information (unused)

### Returns

`string`

SDL string representation of the scalar type

---

## printScalarMetadata() \{#printscalarmetadata\}

```ts
function printScalarMetadata(type, options): Maybe<PageSection>;
```

Defined in: printer-legacy/src/graphql/scalar.ts:47

Prints metadata information for a scalar type.
Currently only includes the specification URL if available.

### Parameters

#### type

`unknown`

The GraphQL scalar type object

#### options

`PrintTypeOptions`

Options for printing type information

### Returns

`Maybe`&lt;[`PageSection`](../events.md#pagesection)&gt;

A scalar metadata PageSection, or undefined when not available

---

## printSpecification() \{#printspecification\}

```ts
function printSpecification(type, options): Maybe<PageSection>;
```

Defined in: printer-legacy/src/graphql/scalar.ts:19

Generates markdown documentation for a scalar type's specification URL.

### Parameters

#### type

`unknown`

The GraphQL scalar type object

#### options

`PrintTypeOptions`

Options for printing type information

### Returns

`Maybe`&lt;[`PageSection`](../events.md#pagesection)&gt;

A specification PageSection, or undefined when no URL exists

---

## union

Module for handling GraphQL Union type printing operations.

## printCodeUnion() \{#printcodeunion\}

```ts
function printCodeUnion(type, options?): string;
```

Defined in: printer-legacy/src/graphql/union.ts:43

Generates GraphQL SDL code representation of a Union type.

### Parameters

#### type

`unknown`

The GraphQL type to process

#### options?

`PrintTypeOptions`

Configuration options for printing (unused)

### Returns

`string`

SDL string representation of the union type

---

## printUnionMetadata() \{#printunionmetadata\}

```ts
function printUnionMetadata(type, options): Maybe<PageSection>;
```

Defined in: printer-legacy/src/graphql/union.ts:23

Generates metadata documentation for a GraphQL Union type.

### Parameters

#### type

`unknown`

The GraphQL type to process

#### options

`PrintTypeOptions`

Configuration options for printing

### Returns

`Maybe`&lt;[`PageSection`](../events.md#pagesection)&gt;

A "Possible types" PageSection, or undefined when `type` is not a union

---

## graphql



---

## group(Printer-legacy)

Utility module for handling GraphQL schema entity grouping.

## getGroup() \{#getgroup\}

```ts
function getGroup(type, groups, typeCategory): string;
```

Defined in: printer-legacy/src/group.ts:24

Retrieves the group name for a given GraphQL type based on its category and group mapping.

### Parameters

#### type

`unknown`

The GraphQL type to get the group for

#### groups

`Maybe`&lt;`Partial`&lt;`Record`&lt;`SchemaEntity`, `Record`&lt;`string`, `Maybe`&lt;`string`&gt;&gt;&gt;&gt;&gt;

Mapping of schema entities to their group names

#### typeCategory

`Maybe`&lt;`SchemaEntity`&gt;

The category of the schema entity

### Returns

`string`

The slugified group name or empty string if no group is found

---

## link

Module for handling links and link-related operations in GraphQL Markdown printer.
Provides utilities for creating, formatting, and managing links to GraphQL types and operations.

## API_GROUPS \{#api_groups\}

```ts
const API_GROUPS: Required<ApiGroupOverrideType>;
```

Defined in: printer-legacy/src/link.ts:52

---

## getCategoryLocale() \{#getcategorylocale\}

```ts
function getCategoryLocale(type): Maybe<TypeLocale>;
```

Defined in: printer-legacy/src/link.ts:103

Gets the locale category for a given GraphQL type.

### Parameters

#### type

`unknown`

The GraphQL type to get the category for

### Returns

`Maybe`&lt;`TypeLocale`&gt;

The locale category for the type, or `undefined` if not found

---

## getLinkApiGroupFolder() \{#getlinkapigroupfolder\}

```ts
function getLinkApiGroupFolder(type, groups?): string;
```

Defined in: printer-legacy/src/link.ts:189

Gets the folder name for an API group based on the GraphQL type and group options.

### Parameters

#### type

`unknown`

The GraphQL type to get the folder name for

#### groups?

`Maybe`&lt;`boolean` \| `ApiGroupOverrideType`&gt;

The group options

### Returns

`string`

The folder name for the API group

---

## getLinkCategoryFolder() \{#getlinkcategoryfolder\}

```ts
function getLinkCategoryFolder(type, operationLocale?): Maybe<string>;
```

Defined in: printer-legacy/src/link.ts:132

Gets the folder name for a link category based on the GraphQL type and operation locale.

### Parameters

#### type

`unknown`

The GraphQL type to get the folder name for

#### operationLocale?

`Maybe`&lt;`TypeLocale`&gt;

The locale of the operation

### Returns

`Maybe`&lt;`string`&gt;

The folder name for the link category, or `undefined` if not found

---

## getLinkDeprecatedFolder() \{#getlinkdeprecatedfolder\}

```ts
function getLinkDeprecatedFolder(type, option): string;
```

Defined in: printer-legacy/src/link.ts:207

Gets the folder name for deprecated types based on the GraphQL type and deprecation option.

### Parameters

#### type

`unknown`

The GraphQL type to get the folder name for

#### option

`Maybe`&lt;`TypeDeprecatedOption`&gt;

The deprecation option

### Returns

`string`

The folder name for deprecated types

---

## getRelationLink() \{#getrelationlink\}

```ts
function getRelationLink(category, type, options): Maybe<TypeLink>;
```

Defined in: printer-legacy/src/link.ts:327

Gets the link for a relation based on the category, type, and options.

### Parameters

#### category

`Maybe`&lt;`TypeLocale`&gt;

The locale category of the relation

#### type

`unknown`

The GraphQL type of the relation

#### options

`PrintLinkOptions`

Configuration options for link generation

### Returns

`Maybe`&lt;`TypeLink`&gt;

The link object for the relation, or `undefined` if not found

---

## hasOptionParentType() \{#hasoptionparenttype\}

```ts
function hasOptionParentType(options): boolean;
```

Defined in: printer-legacy/src/link.ts:173

Checks if the options include the `parentTypePrefix` attribute.

### Parameters

#### options

`PrintLinkOptions`

The options to check

### Returns

`boolean`

`true` if the options include `parentTypePrefix`, `false` otherwise

---

## hasOptionWithAttributes() \{#hasoptionwithattributes\}

```ts
function hasOptionWithAttributes(options): boolean;
```

Defined in: printer-legacy/src/link.ts:163

Checks if the options include the `withAttributes` attribute.

### Parameters

#### options

`PrintLinkOptions`

The options to check

### Returns

`boolean`

`true` if the options include `withAttributes`, `false` otherwise

---

## hasPrintableDirective() \{#hasprintabledirective\}

```ts
function hasPrintableDirective(type, options?): boolean;
```

Defined in: printer-legacy/src/link.ts:64

Checks if a type has printable directives based on the provided options.

### Parameters

#### type

`unknown`

The GraphQL type to check

#### options?

`Pick`&lt;`PrintTypeOptions`, `"deprecated"` \| `"onlyDocDirectives"` \| `"skipDocDirectives"`&gt;

Configuration options for directive printing (`deprecated`, `onlyDocDirectives`, `skipDocDirectives`)

### Returns

`boolean`

`true` if the type should be printed, `false` otherwise

---

## printLink() \{#printlink\}

```ts
function printLink<T>(arg, options): string;
```

Defined in: printer-legacy/src/link.ts:398

Prints a link for a GraphQL type based on the provided options.

### Type Parameters

#### T

`T`

### Parameters

#### arg

`Maybe`&lt;`TypeLink`&gt; \| `T`

The GraphQL type or link object to print a link for

#### options

`PrintLinkOptions`

Configuration options for link generation

### Returns

`string`

The formatted link as a string

---

## printLinkAttributes() \{#printlinkattributes\}

```ts
function printLinkAttributes(type, text?): string;
```

Defined in: printer-legacy/src/link.ts:350

Prints the attributes of a link based on the GraphQL type.

### Parameters

#### type

`unknown`

The GraphQL type to print attributes for

#### text?

`Maybe`&lt;`string`&gt; = `""`

The text to append attributes to

### Returns

`string`

The text with appended attributes

---

## printParentLink() \{#printparentlink\}

```ts
function printParentLink(type, options): string | MDXString;
```

Defined in: printer-legacy/src/link.ts:442

Prints a parent link for a GraphQL type based on the provided options.

### Parameters

#### type

`unknown`

The GraphQL type to print a parent link for

#### options

`PrintLinkOptions`

Configuration options for link generation

### Returns

`string` \| `MDXString`

The formatted parent link as a string or MDX string

---

## toLink() \{#tolink\}

```ts
function toLink(type, name, operation, options): TypeLink;
```

Defined in: printer-legacy/src/link.ts:230

Converts a GraphQL type to a link object.

### Parameters

#### type

`unknown`

The GraphQL type to convert

#### name

`string`

The name of the type

#### operation

`Maybe`&lt;`TypeLocale`&gt;

The locale of the operation

#### options

`PrintLinkOptions`

Configuration options for link generation

### Returns

`TypeLink`

The link object for the type

---

## mdx(Printer-legacy)

MDX formatting module for GraphQL-Markdown.

This module provides a set of utility functions for formatting various MDX components
used in the documentation generation process. It handles the formatting of badges,
admonitions, bullet points, collapsible sections, and other MDX-specific elements.

The module can be used with default formatters or customized with user-provided
MDX formatting functions through the mdxModule factory function.

## default \{#default\}

```ts
const default: MDXSupportType;
```

Defined in: printer-legacy/src/mdx/index.ts:197

---

## mdxDeclaration \{#mdxdeclaration\}

```ts
const mdxDeclaration: "" = "";
```

Defined in: printer-legacy/src/mdx/index.ts:195

---

## mdxModule() \{#mdxmodule\}

```ts
function mdxModule(mdxPackage?): Promise<Readonly<MDXSupportType>>;
```

Defined in: printer-legacy/src/mdx/index.ts:208

### Parameters

#### mdxPackage?

`Record`&lt;`string`, `unknown`&gt;

### Returns

`Promise`&lt;`Readonly`&lt;`MDXSupportType`&gt;&gt;

---

## printer(Printer-legacy)

GraphQL Schema Printer Module

This module provides functionality for printing GraphQL schema types into Markdown documentation.
It includes utilities for handling various GraphQL types, custom directives, and formatting options.

## Printer \{#printer\}

Defined in: printer-legacy/src/printer.ts:157

The Printer class implements the core functionality for generating Markdown documentation
from GraphQL schema types.

### Remarks

This class provides static methods for rendering different components of the documentation:

- Headers and frontmatter
- Type descriptions and code blocks
- Custom directives and metadata
- Examples and relations

### Example

```typescript
const printer = new Printer();
await printer.init(schema, "/docs", "graphql", options);
const docs = printer.printType("Query", queryType);
```

### Implements

- `IPrinter`

### Constructors

#### Constructor

```ts
new Printer(): Printer;
```

##### Returns

[`Printer`](#printer)

### Properties

#### printCustomDirectives \{#printcustomdirectives\}

```ts
readonly static printCustomDirectives: (type, options) => Maybe<PageSection>;
```

Defined in: printer-legacy/src/printer.ts:166

Prints custom directives

Prints all custom directives for a type as a Markdown section

##### Parameters

###### type

`unknown`

The GraphQL type to print directives for

###### options

`PrintTypeOptions`

General printing options

##### Returns

`Maybe`&lt;[`PageSection`](events.md#pagesection)&gt;

A "Directives" PageSection, or undefined when no directives are printable

#### printCustomTags \{#printcustomtags\}

```ts
readonly static printCustomTags: (type, options) => string | MDXString;
```

Defined in: printer-legacy/src/printer.ts:171

Prints custom tags

Prints custom directive tags as Markdown badges

##### Parameters

###### type

`unknown`

The GraphQL type to print tags for

###### options

`PrintTypeOptions`

General printing options

##### Returns

`string` \| `MDXString`

Formatted Markdown string of badges or empty string

#### printDescription \{#printdescription\}

```ts
readonly static printDescription: (type, options, noText?) => string | MDXString;
```

Defined in: printer-legacy/src/printer.ts:161

Prints type descriptions

Prints the complete description for a GraphQL type, including deprecation warnings and custom directives.

##### Parameters

###### type

`unknown`

The GraphQL type to document

###### options

`PrintTypeOptions`

Configuration options for printing

###### noText?

`string`

Optional text to display when no description exists

##### Returns

`string` \| `MDXString`

Combined description, deprecation notices, and custom directives as MDX content

### Accessors

#### deprecatedOptions \{#deprecatedoptions\}

##### Get Signature

```ts
get static deprecatedOptions(): Readonly<Maybe<DeprecatedPrintTypeOptions>>;
```

Defined in: printer-legacy/src/printer.ts:195

Backward-compat section toggles extracted from legacy config options.

These flags are applied only during section order composition.

###### Returns

`Readonly`&lt;`Maybe`&lt;`DeprecatedPrintTypeOptions`&gt;&gt;

#### eventEmitter \{#eventemitter\}

##### Get Signature

```ts
get static eventEmitter(): Maybe<PrinterEventEmitter>;
```

Defined in: printer-legacy/src/printer.ts:204

Optional event emitter for print events.
When set, the printer will emit events before/after printCode and printType,
allowing external code to intercept and modify the output.

###### Returns

`Maybe`&lt;`PrinterEventEmitter`&gt;

##### Set Signature

```ts
set static eventEmitter(eventEmitter): void;
```

Defined in: printer-legacy/src/printer.ts:219

###### Parameters

###### eventEmitter

`Maybe`&lt;`PrinterEventEmitter`&gt;

###### Returns

`void`

#### mdxDeclaration \{#mdxdeclaration\}

##### Get Signature

```ts
get static mdxDeclaration(): Readonly<Maybe<string>>;
```

Defined in: printer-legacy/src/printer.ts:211

Prints mdx modules import declaration

###### Returns

`Readonly`&lt;`Maybe`&lt;`string`&gt;&gt;

##### Set Signature

```ts
set static mdxDeclaration(mdxDeclaration): void;
```

Defined in: printer-legacy/src/printer.ts:223

###### Parameters

###### mdxDeclaration

`Readonly`&lt;`Maybe`&lt;`string`&gt;&gt;

###### Returns

`void`

#### options \{#options\}

##### Get Signature

```ts
get static options(): Readonly<Maybe<PrintTypeOptions>>;
```

Defined in: printer-legacy/src/printer.ts:186

Global printer configuration options

###### Returns

`Readonly`&lt;`Maybe`&lt;`PrintTypeOptions`&gt;&gt;

##### Set Signature

```ts
set static options(options): void;
```

Defined in: printer-legacy/src/printer.ts:215

###### Parameters

###### options

`Readonly`&lt;`Maybe`&lt;`PrintTypeOptions`&gt;&gt;

###### Returns

`void`

### Methods

#### init() \{#init\}

```ts
static init(
   schema,
   baseURL?,
   linkRoot?,
   options?,
   formatter?,
   mdxDeclaration?,
   eventEmitter?): Promise<void>;
```

Defined in: printer-legacy/src/printer.ts:238

Initializes the printer with the given schema and configuration.

##### Parameters

###### schema

`Maybe`&lt;`GraphQLSchema`&gt;

GraphQL schema to generate documentation for

###### baseURL?

`Maybe`&lt;`string`&gt; = `"schema"`

Base URL path for documentation, e.g. '/docs'

###### linkRoot?

`Maybe`&lt;`string`&gt; = `"/"`

Root path for generating links between types

###### options?

Configuration options for the printer

###### customDirectives?

`CustomDirectiveMap`

###### deprecated?

`TypeDeprecatedOption`

###### groups?

`Partial`&lt;`Record`&lt;`SchemaEntity`, `Record`&lt;`string`, `Maybe`&lt;`string`&gt;&gt;&gt;&gt;

###### meta?

`Maybe`&lt;`MetaInfo`&gt;

###### metatags?

`Record`&lt;`string`, `string`&gt;[]

###### onlyDocDirectives?

`GraphQLDirective`[]

###### printTypeOptions?

`InitPrintTypeOptions`

###### sectionHeaderId?

`boolean`

###### skipDocDirectives?

`GraphQLDirective`[]

###### formatter?

`Partial`&lt;`Formatter`&gt;

Optional formatter functions for customizing output format

###### mdxDeclaration?

`Maybe`&lt;`string`&gt;

Optional MDX import declaration

###### eventEmitter?

`Maybe`&lt;`PrinterEventEmitter`&gt;

Optional event emitter for print events interception

##### Returns

`Promise`&lt;`void`&gt;

#### printCode() \{#printcode\}

```ts
readonly static printCode(type, options): string;
```

Defined in: printer-legacy/src/printer.ts:354

Prints the GraphQL type definition as code block

##### Parameters

###### type

`unknown`

GraphQL type to print

###### options

`PrintTypeOptions`

Printer configuration options

##### Returns

`string`

Formatted code block string with type definition

#### printCodeAsync() \{#printcodeasync\}

```ts
readonly static printCodeAsync(
   type,
   typeName,
   options): Promise<string>;
```

Defined in: printer-legacy/src/printer.ts:410

Prints the GraphQL type definition as code block with event emission support.

##### Parameters

###### type

`unknown`

GraphQL type to print

###### typeName

`string`

Name of the type being printed

###### options

`PrintTypeOptions`

Printer configuration options

##### Returns

`Promise`&lt;`string`&gt;

Promise resolving to formatted code block string with type definition

##### Remarks

This async version emits events before and after code generation:

- `print:beforePrintCode` - Emitted before generating code (can modify inputs or prevent default)
- `print:afterPrintCode` - Emitted after generating code (can modify output)

Event handlers can:

- Modify `event.data.options` in BEFORE to affect code generation
- Call `event.preventDefault()` in BEFORE to skip default generation and provide custom output
- Modify `event.output` in AFTER to change the final result

#### printExample() \{#printexample\}

```ts
readonly static printExample(type, options): Maybe<PageSection>;
```

Defined in: printer-legacy/src/printer.ts:455

Prints example usage of the type if available

##### Parameters

###### type

`unknown`

GraphQL type to generate example for

###### options

`PrintTypeOptions`

Printer configuration options

##### Returns

`Maybe`&lt;[`PageSection`](events.md#pagesection)&gt;

Example page section or undefined when no example is available

#### printHeader() \{#printheader\}

```ts
readonly static printHeader(
   id,
   title,
   options): string;
```

Defined in: printer-legacy/src/printer.ts:333

Prints the header section of a type documentation

##### Parameters

###### id

`string`

Unique identifier for the type

###### title

`string`

Display title for the type

###### options

`PrintTypeOptions`

Printer configuration options

##### Returns

`string`

Formatted header string with optional frontmatter

#### printMetaTags() \{#printmetatags\}

```ts
readonly static printMetaTags(_type, options): string | MDXString;
```

Defined in: printer-legacy/src/printer.ts:528

Prints HTML meta tags for the documentation

##### Parameters

###### \_type

`unknown`

GraphQL type (unused)

###### options

`PrintTypeOptions`

Printer configuration options containing metatags

##### Returns

`string` \| `MDXString`

Formatted HTML meta tags string

#### printRelations() \{#printrelations\}

```ts
readonly static printRelations(type, options): string | MDXString;
```

Defined in: printer-legacy/src/printer.ts:514

Prints related type information

##### Parameters

###### type

`unknown`

GraphQL type to find relations for

###### options

`PrintTypeOptions`

Printer configuration options

##### Returns

`string` \| `MDXString`

Formatted relations section as MDX or plain string

#### printType() \{#printtype\}

```ts
readonly static printType(
   name,
   type,
   options?): Promise<Maybe<MDXString>>;
```

Defined in: printer-legacy/src/printer.ts:578

Main method to print complete documentation for a GraphQL type

##### Parameters

###### name

`Maybe`&lt;`string`&gt;

Name identifier for the type

###### type

`unknown`

GraphQL type to generate documentation for

###### options?

`Maybe`&lt;`Partial`&lt;`PrintTypeOptions`&gt;&gt;

Optional printer configuration options

##### Returns

`Promise`&lt;`Maybe`&lt;`MDXString`&gt;&gt;

Complete documentation as MDX string or undefined if type should be skipped

##### Example

```typescript
const doc = await Printer.printType("User", UserType, {
  frontMatter: true,
});
```

##### Remarks

The method combines multiple sections:

- Header with frontmatter
- Meta tags
- Description
- Code definition
- Custom directives
- Type metadata
- Example usage
- Related types

When an event emitter is configured, emits events:

- `print:beforePrintType` - Before generating documentation
- `print:beforeComposePageType` - Before composing section order and final page output
- `print:afterPrintType` - After generating documentation (output can be modified)

#### printTypeMetadata() \{#printtypemetadata\}

```ts
readonly static printTypeMetadata(type, options): Maybe<
  | PageSection
  | PageSection[]>;
```

Defined in: printer-legacy/src/printer.ts:478

Prints metadata information for a GraphQL type

##### Parameters

###### type

`unknown`

GraphQL type to print metadata for

###### options

`PrintTypeOptions`

Printer configuration options

##### Returns

`Maybe`&lt;
\| [`PageSection`](events.md#pagesection)
\| [`PageSection`](events.md#pagesection)[]&gt;

Metadata section (or section list) for supported types, otherwise undefined

---

## relation(Printer-legacy)

This module provides functionality to print relationships between GraphQL types,
including return types, member fields, and implementations, in a formatted MDX string output.

## getRootTypeLocaleFromString() \{#getroottypelocalefromstring\}

```ts
function getRootTypeLocaleFromString(text): Maybe<TypeLocale>;
```

Defined in: printer-legacy/src/relation.ts:40

Converts a string representation of a root type to its corresponding `TypeLocale`

### Parameters

#### text

`string`

The string to convert to a `TypeLocale`

### Returns

`Maybe`&lt;`TypeLocale`&gt;

The matching `TypeLocale` if found, `undefined` otherwise

### Example

```ts
const locale = getRootTypeLocaleFromString("Query");
```

---

## printRelationOf() \{#printrelationof\}

```ts
function printRelationOf<T>(
  type,
  section,
  getRelation,
  options,
): string | MDXString;
```

Defined in: printer-legacy/src/relation.ts:65

Prints the relation section for a specific type and relation category

### Type Parameters

#### T

`T`

Type of the relation

### Parameters

#### type

`unknown`

The GraphQL type to get relations for

#### section

`unknown`

The section title for the relation

#### getRelation

`Maybe`&lt;`IGetRelation`&lt;`T`&gt;&gt;

Function to retrieve relations of type T

#### options

`PrintTypeOptions`

Printing options for type formatting

### Returns

`string` \| `MDXString`

Formatted MDX string containing the relations or empty string if no relations found

### Throws

If the schema is not provided in options

### Example

```ts
const mdx = printRelationOf(type, "Member Of", getRelationOfField, options);
```

---

## printRelations() \{#printrelations\}

```ts
function printRelations(type, options): string | MDXString;
```

Defined in: printer-legacy/src/relation.ts:134

Prints all relations (return types, member fields, and implementations) for a given type

### Parameters

#### type

`unknown`

The GraphQL type to get all relations for

#### options

`PrintTypeOptions`

Printing options for type formatting

### Returns

`string` \| `MDXString`

Formatted MDX string containing all relations or empty string if no relations found

### Throws

If the schema is not provided in options

### Example

```ts
const relations = printRelations(myType, {
  schema,
  formatMDXBullet: () => "* ",
});
```

---

## section

Module responsible for generating Markdown sections for GraphQL schema documentation.
Handles the printing of section items, metadata, and structured documentation content.

## printMetadataSection() \{#printmetadatasection\}

```ts
function printMetadataSection<T, V>(
  type,
  values,
  section,
  options,
): Maybe<PageSection>;
```

Defined in: printer-legacy/src/section.ts:195

Prints a metadata section with special handling for deprecated items.

### Type Parameters

#### T

`T`

Type of the parent element

#### V

`V`

Type of the values being printed

### Parameters

#### type

`T`

The parent type containing the metadata

#### values

`V` \| `V`[] \| readonly `V`[]

Values to include in the metadata section

#### section

`string`

Section title/header

#### options

`PrintTypeOptions`

Configuration options for printing

### Returns

`Maybe`&lt;[`PageSection`](events.md#pagesection)&gt;

Formatted MDX string containing the metadata section

---

## printSection() \{#printsection\}

```ts
function printSection<V>(values, section, options): Maybe<PageSection>;
```

Defined in: printer-legacy/src/section.ts:140

Prints a complete section with title and content.

### Type Parameters

#### V

`V`

Type of the values being printed

### Parameters

#### values

`V`[] \| readonly `V`[]

Array of values to include in the section

#### section

`string`

Section title/header

#### options

`PrintTypeOptions`

Configuration options for printing

### Returns

`Maybe`&lt;[`PageSection`](events.md#pagesection)&gt;

Formatted MDX string containing the complete section

---

## printSectionItem() \{#printsectionitem\}

```ts
function printSectionItem<T>(type, options): string | MDXString;
```

Defined in: printer-legacy/src/section.ts:46

Prints a single section item with its associated metadata.

### Type Parameters

#### T

`T`

Type of the GraphQL element being printed

### Parameters

#### type

`T`

The GraphQL type or field to print

#### options

`PrintTypeOptions`

Configuration options for printing

### Returns

`string` \| `MDXString`

Formatted MDX string containing the section item

---

## printSectionItems() \{#printsectionitems\}

```ts
function printSectionItems<V>(values, options): string | MDXString;
```

Defined in: printer-legacy/src/section.ts:108

Prints an array of section items with consistent formatting.

### Type Parameters

#### V

`V`

Type of the values being printed

### Parameters

#### values

`V` \| `V`[]

Single value or array of values to print as section items

#### options

`PrintTypeOptions`

Configuration options for printing

### Returns

`string` \| `MDXString`

Formatted MDX string containing all section items

---

## array

Internal library of helpers for manipulating array and list.

## convertArrayToMapObject() \{#convertarraytomapobject\}

```ts
function convertArrayToMapObject<T>(list): Maybe<Record<string, T>>;
```

Defined in: array.ts:75

**`Internal`**

Returns a k/v object from an array of objects with a `name` property.

### Type Parameters

#### T

`T`

the type of objects the list contains.

### Parameters

#### list

`Maybe`&lt;`T`[]&gt;

the list of objects of type `{ name: any }` to be converted.

### Returns

`Maybe`&lt;`Record`&lt;`string`, `T`&gt;&gt;

an array of object values with `name` as key, or `undefined` if `list` is not a valid array.

### Example

```js

convertArrayToMapObject([
  { name: true },
  { name: "test" },
  { name: 123 },
  { name2: 1234 },
]);

// Expected result: {
//   true: { name: true },
//   test: { name: "test" },
//   "123": { name: 123 },
// }
```

---

## toArray() \{#toarray\}

```ts
function toArray(recordMap): Maybe<unknown[]>;
```

Defined in: array.ts:35

**`Internal`**

Returns an array of values from a k/v object.

### Parameters

#### recordMap

`Maybe`&lt;`Record`&lt;`string`, `unknown`&gt;&gt;

the key/value record object to be converted.

### Returns

`Maybe`&lt;`unknown`[]&gt;

an array of object values, or `undefined` if `recordMap` is not a valid object.

### Example

```js

toArray({
  bool: true,
  string: "test",
  number: 123,
  array: ["one", "two"],
  child: { key: "value" },
});

// Expected result: [true, "test", 123, ["one", "two"], { key: "value" }]
```

---

## events(Utils)

Base event class and utilities for GraphQL-Markdown events.

## Events

### `abstract` CancellableEvent \{#abstract-cancellableevent\}

Defined in: events.ts:55

Base class for all cancellable events in GraphQL-Markdown.

Provides common functionality:

- preventDefault() to cancel default actions
- stopPropagation() to halt handler chain
- Configurable cancellability
- Optional default action function

#### Extended by

- [`DataEvent`](#abstract-dataevent)

#### Implements

- `ICancellableEvent`

#### Constructors

##### Constructor

```ts
new CancellableEvent(options?): CancellableEvent;
```

Defined in: events.ts:88

Creates a new CancellableEvent.

###### Parameters

###### options?

[`CancellableEventOptions`](#cancellableeventoptions)

Configuration options for the event

###### Returns

[`CancellableEvent`](#abstract-cancellableevent)

###### Remarks

options.cancellable controls whether this event can be cancelled (default: true).
options.defaultAction defines an optional function to execute as default action.

#### Accessors

##### defaultAction \{#defaultaction\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: events.ts:110

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Implementation of

```ts
ICancellableEvent.defaultAction;
```

##### defaultPrevented \{#defaultprevented\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: events.ts:96

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: events.ts:117

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Implementation of

```ts
ICancellableEvent.defaultPrevented;
```

##### propagationStopped \{#propagationstopped\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: events.ts:103

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: events.ts:126

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Implementation of

```ts
ICancellableEvent.propagationStopped;
```

#### Methods

##### preventDefault() \{#preventdefault\}

```ts
preventDefault(): void;
```

Defined in: events.ts:136

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Implementation of

```ts
ICancellableEvent.preventDefault;
```

##### runDefaultAction() \{#rundefaultaction\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: events.ts:153

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Implementation of

```ts
ICancellableEvent.runDefaultAction;
```

##### stopPropagation() \{#stoppropagation\}

```ts
stopPropagation(): void;
```

Defined in: events.ts:146

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Implementation of

```ts
ICancellableEvent.stopPropagation;
```

---

### `abstract` DataEvent \{#abstract-dataevent\}

Defined in: events.ts:168

Abstract base for events that carry a typed, read-only data payload.

#### Extends

- [`CancellableEvent`](#abstract-cancellableevent)

#### Extended by

- [`DataOutputEvent`](#abstract-dataoutputevent)
- [`DiffCheckEvent`](../core/events/diff-check.md#diffcheckevent)
- [`GenerateIndexMetafileEvent`](../core/events/generate-index-metafile.md#generateindexmetafileevent)
- [`RenderHomepageEvent`](../core/events/render-homepage.md#renderhomepageevent)
- [`RenderRootTypesEvent`](../core/events/render-root-types.md#renderroottypesevent)
- [`RenderTypeEntitiesEvent`](../core/events/render-type-entities.md#rendertypeentitiesevent)
- [`SchemaEvent`](../core/events/schema-load.md#schemaevent)

#### Type Parameters

##### TData

`TData`

Type of the event data payload.

#### Constructors

##### Constructor

```ts
new DataEvent<TData>(data, options?): DataEvent<TData>;
```

Defined in: events.ts:172

###### Parameters

###### data

`TData`

###### options?

[`CancellableEventOptions`](#cancellableeventoptions)

###### Returns

[`DataEvent`](#abstract-dataevent)&lt;`TData`&gt;

###### Overrides

[`CancellableEvent`](#abstract-cancellableevent).[`constructor`](#constructor)

#### Properties

##### data \{#data\}

```ts
readonly data: TData;
```

Defined in: events.ts:170

Read-only event data payload.

#### Accessors

##### defaultAction \{#defaultaction-1\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: events.ts:110

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Inherited from

[`CancellableEvent`](#abstract-cancellableevent).[`defaultAction`](#defaultaction)

##### defaultPrevented \{#defaultprevented-1\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: events.ts:96

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: events.ts:117

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`CancellableEvent`](#abstract-cancellableevent).[`defaultPrevented`](#defaultprevented)

##### propagationStopped \{#propagationstopped-1\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: events.ts:103

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: events.ts:126

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`CancellableEvent`](#abstract-cancellableevent).[`propagationStopped`](#propagationstopped)

#### Methods

##### preventDefault() \{#preventdefault-1\}

```ts
preventDefault(): void;
```

Defined in: events.ts:136

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Inherited from

[`CancellableEvent`](#abstract-cancellableevent).[`preventDefault`](#preventdefault)

##### runDefaultAction() \{#rundefaultaction-1\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: events.ts:153

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Inherited from

[`CancellableEvent`](#abstract-cancellableevent).[`runDefaultAction`](#rundefaultaction)

##### stopPropagation() \{#stoppropagation-1\}

```ts
stopPropagation(): void;
```

Defined in: events.ts:146

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Inherited from

[`CancellableEvent`](#abstract-cancellableevent).[`stopPropagation`](#stoppropagation)

---

### `abstract` DataOutputEvent \{#abstract-dataoutputevent\}

Defined in: events.ts:186

Abstract base for events that carry typed data and a mutable output value.

#### Extends

- [`DataEvent`](#abstract-dataevent)&lt;`TData`&gt;

#### Extended by

- [`BeforeComposePageTypeEvent`](../printer-legacy/events.md#beforecomposepagetypeevent)
- [`PrintCodeEvent`](../printer-legacy/events.md#printcodeevent)
- [`PrintTypeEvent`](../printer-legacy/events.md#printtypeevent)

#### Type Parameters

##### TData

`TData`

Type of the event data payload.

##### TOutput

`TOutput`

Type of the mutable output value.

#### Constructors

##### Constructor

```ts
new DataOutputEvent<TData, TOutput>(
   data,
   initialOutput,
   options?): DataOutputEvent<TData, TOutput>;
```

Defined in: events.ts:193

###### Parameters

###### data

`TData`

###### initialOutput

`TOutput`

###### options?

[`CancellableEventOptions`](#cancellableeventoptions)

###### Returns

[`DataOutputEvent`](#abstract-dataoutputevent)&lt;`TData`, `TOutput`&gt;

###### Overrides

[`DataEvent`](#abstract-dataevent).[`constructor`](#constructor-1)

#### Properties

##### data \{#data-1\}

```ts
readonly data: TData;
```

Defined in: events.ts:170

Read-only event data payload.

###### Inherited from

[`DataEvent`](#abstract-dataevent).[`data`](#data)

##### output \{#output\}

```ts
output: TOutput;
```

Defined in: events.ts:191

The generated output.
Handlers can modify this property to change the final result.

#### Accessors

##### defaultAction \{#defaultaction-2\}

###### Get Signature

```ts
get defaultAction(): DefaultAction | undefined;
```

Defined in: events.ts:110

Gets the default action function if one was provided.

###### Returns

`DefaultAction` \| `undefined`

###### Inherited from

[`DataEvent`](#abstract-dataevent).[`defaultAction`](#defaultaction-1)

##### defaultPrevented \{#defaultprevented-2\}

###### Get Signature

```ts
get defaultPrevented(): boolean;
```

Defined in: events.ts:96

Gets whether the default action has been prevented.

###### Returns

`boolean`

###### Set Signature

```ts
set defaultPrevented(value): void;
```

Defined in: events.ts:117

Allows setting defaultPrevented to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](#abstract-dataevent).[`defaultPrevented`](#defaultprevented-1)

##### propagationStopped \{#propagationstopped-2\}

###### Get Signature

```ts
get propagationStopped(): boolean;
```

Defined in: events.ts:103

Gets whether propagation has been stopped.

###### Returns

`boolean`

###### Set Signature

```ts
set propagationStopped(value): void;
```

Defined in: events.ts:126

Allows setting propagationStopped to true directly.

###### Parameters

###### value

`boolean`

###### Returns

`void`

###### Inherited from

[`DataEvent`](#abstract-dataevent).[`propagationStopped`](#propagationstopped-1)

#### Methods

##### preventDefault() \{#preventdefault-2\}

```ts
preventDefault(): void;
```

Defined in: events.ts:136

Prevents the default action from executing.
Only works if the event is cancellable.

###### Returns

`void`

###### Inherited from

[`DataEvent`](#abstract-dataevent).[`preventDefault`](#preventdefault-1)

##### runDefaultAction() \{#rundefaultaction-2\}

```ts
runDefaultAction(): Promise<void>;
```

Defined in: events.ts:153

Executes the default action for an event if it hasn't been prevented.

###### Returns

`Promise`&lt;`void`&gt;

###### Inherited from

[`DataEvent`](#abstract-dataevent).[`runDefaultAction`](#rundefaultaction-1)

##### stopPropagation() \{#stoppropagation-2\}

```ts
stopPropagation(): void;
```

Defined in: events.ts:146

Stops propagation to remaining event handlers.
Handlers registered after the current one will not execute.

###### Returns

`void`

###### Inherited from

[`DataEvent`](#abstract-dataevent).[`stopPropagation`](#stoppropagation-1)

## Other

### CancellableEventOptions \{#cancellableeventoptions\}

Defined in: events.ts:39

#### Properties

##### cancellable? \{#cancellable\}

```ts
optional cancellable?: boolean;
```

Defined in: events.ts:41

##### defaultAction? \{#defaultaction-3\}

```ts
optional defaultAction?: DefaultAction;
```

Defined in: events.ts:40

---

### deepFreeze() \{#deepfreeze\}

```ts
function deepFreeze<T>(obj): T;
```

Defined in: events.ts:23

Deep freezes an object to make it immutable at runtime.
Recursively freezes all nested objects and arrays.

#### Type Parameters

##### T

`T` _extends_ `Record`&lt;`PropertyKey`, `any`&gt;

#### Parameters

##### obj

`T`

The object to freeze

#### Returns

`T`

The frozen object (same reference)

#### Example

```typescript
const data = { user: { name: "John" } };
deepFreeze(data);
data.user.name = "Jane"; // Throws error in strict mode
```

---

## frontmatter(Utils)

Routines for serializing data structures into Markdown frontmatter blocks.

## formatFrontMatterList() \{#formatfrontmatterlist\}

```ts
function formatFrontMatterList(prop, indentation?, prefix?): string[];
```

Defined in: frontmatter.ts:84

Formats an array into a front matter YAML-like structure as string array.

### Parameters

#### prop

`unknown`

The array to format.

#### indentation?

`number` = `0`

The current indentation level. Defaults to 0.

#### prefix?

`string` = `"- "`

The prefix for each list item. Defaults to "- ".

### Returns

`string`[]

An array of strings representing the formatted front matter list.

### Example

```typescript
const list = ["item1", "item2"];
formatFrontMatterList(list);
// [
//   "- item1",
//   "- item2"
// ]
```

---

## formatFrontMatterObject() \{#formatfrontmatterobject\}

```ts
function formatFrontMatterObject(props, indentation?, prefix?): string[];
```

Defined in: frontmatter.ts:44

Formats an object into a front matter YAML-like structure as string array.

### Parameters

#### props

`unknown`

The object to format.

#### indentation?

`number` = `0`

The current indentation level. Defaults to 0.

#### prefix?

`string`

An optional prefix for each line.

### Returns

`string`[]

An array of strings representing the formatted front matter.

### Example

```typescript
const obj = { title: "My Title", tags: ["tag1", "tag2"] };
formatFrontMatterObject(obj);
// [
//   "  title: My Title",
//   "  tags:",
//   "    - tag1",
//   "    - tag2"
// ]
```

---

## formatFrontMatterProp() \{#formatfrontmatterprop\}

```ts
function formatFrontMatterProp(prop, indentation?, prefix?): string[];
```

Defined in: frontmatter.ts:127

Formats a single property into a front matter YAML-like structure as string array.

### Parameters

#### prop

`unknown`

The property to format, represented as an object with a single key-value pair.

#### indentation?

`number` = `0`

The current indentation level. Defaults to 0.

#### prefix?

`string`

An optional prefix for the property.

### Returns

`string`[]

An array of strings representing the formatted front matter property.

### Example

```typescript
const prop = { title: "My Title" };
formatFrontMatterProp(prop);
// [
//   "title: My Title"
// ]
```

---

## fs

Library of helper functions for handling files and folders.

## ensureDir() \{#ensuredir\}

```ts
function ensureDir(location, options?): Promise<void>;
```

Defined in: fs.ts:60

Asynchronously create a folder structure if it does not exist.

### Parameters

#### location

`string`

folder structure in path format.

#### options?

`EnsureDirOptions`

### Returns

`Promise`&lt;`void`&gt;

### Example

```js

await ensureDir("./.temp/local");

// Creates both folders if they do not exists.
```

---

## fileExists() \{#fileexists\}

```ts
function fileExists(location): Promise<boolean>;
```

Defined in: fs.ts:35

Asynchronously check if a file or folder exists at the path location.

### Parameters

#### location

`string`

file or folder location.

### Returns

`Promise`&lt;`boolean`&gt;

`true` if the path is valid, else `false` if not.

### Example

```js

await fileExists("./.temp/local");

// Expected true if path is valid, false if not
```

---

## saveFile() \{#savefile\}

```ts
function saveFile(location, content, prettify?): Promise<void>;
```

Defined in: fs.ts:97

Asynchronously save a file with a string content at specified location in local FS.
Override the file content if the file already exists.
The function calls `ensureDir(dirname(location))` to create the folder structure if missing.

### Parameters

#### location

`string`

file location.

#### content

`string`

data to be written into the file (UTF-8 string).

#### prettify?

`PrettifyCallbackFunction`

optional callback function for prettifying the content.

### Returns

`Promise`&lt;`void`&gt;

`true` if the path is valid, else `false` if not.

### Example

```js

await saveFile("./.temp/local.md", "foobar");

// Created .temp folder if it does not exists, and save data into local.md
```

---

## guards

Type guard utilities for common validation patterns.

This module consolidates reusable type guards that are used throughout
the codebase for validating GraphQL schema objects and other entities.

## hasArrayProperty() \{#hasarrayproperty\}

### Call Signature

```ts
function hasArrayProperty<K>(obj, key): obj is Record<K, unknown[]>;
```

Defined in: guards.ts:111

Type guard to check if an object has an array property.

#### Type Parameters

##### K

`K` _extends_ `PropertyKey`

#### Parameters

##### obj

`unknown`

The object to check

##### key

`K`

The property name to look for

#### Returns

`obj is Record<K, unknown[]>`

`true` if the property exists and is an array, `false` otherwise

#### Example

```typescript

if (hasArrayProperty(type, "args")) {
  // type.args is now typed as unknown[]
  console.log(type.args.length);
}
```

### Call Signature

```ts
function hasArrayProperty(obj, key): obj is Record<PropertyKey, unknown[]>;
```

Defined in: guards.ts:116

Type guard to check if an object has an array property.

#### Parameters

##### obj

`unknown`

The object to check

##### key

`PropertyKey`

The property name to look for

#### Returns

`obj is Record<PropertyKey, unknown[]>`

`true` if the property exists and is an array, `false` otherwise

#### Example

```typescript

if (hasArrayProperty(type, "args")) {
  // type.args is now typed as unknown[]
  console.log(type.args.length);
}
```

---

## hasFunctionProperty() \{#hasfunctionproperty\}

### Call Signature

```ts
function hasFunctionProperty<K>(
  obj,
  key,
): obj is Record<K, (args: unknown[]) => unknown>;
```

Defined in: guards.ts:213

Type guard to check if an object has a function property.

#### Type Parameters

##### K

`K` _extends_ `PropertyKey`

#### Parameters

##### obj

`unknown`

The object to check

##### key

`K`

The property name to look for

#### Returns

`obj is Record<K, (args: unknown[]) => unknown>`

`true` if the property exists and is a function, `false` otherwise

#### Example

```typescript

if (hasFunctionProperty(directive, "descriptor")) {
  // directive.descriptor is now typed as a function
  directive.descriptor();
}
```

### Call Signature

```ts
function hasFunctionProperty(
  obj,
  key,
): obj is Record<PropertyKey, (args: unknown[]) => unknown>;
```

Defined in: guards.ts:218

Type guard to check if an object has a function property.

#### Parameters

##### obj

`unknown`

The object to check

##### key

`PropertyKey`

The property name to look for

#### Returns

`obj is Record<PropertyKey, (args: unknown[]) => unknown>`

`true` if the property exists and is a function, `false` otherwise

#### Example

```typescript

if (hasFunctionProperty(directive, "descriptor")) {
  // directive.descriptor is now typed as a function
  directive.descriptor();
}
```

---

## hasNonEmptyArrayProperty() \{#hasnonemptyarrayproperty\}

### Call Signature

```ts
function hasNonEmptyArrayProperty<K>(obj, key): obj is Record<K, unknown[]>;
```

Defined in: guards.ts:145

Type guard to check if an object has a non-empty array property.

#### Type Parameters

##### K

`K` _extends_ `PropertyKey`

#### Parameters

##### obj

`unknown`

The object to check

##### key

`K`

The property name to look for

#### Returns

`obj is Record<K, unknown[]>`

`true` if the property exists, is an array, and is non-empty, `false` otherwise

#### Example

```typescript

if (hasNonEmptyArrayProperty(type, "args")) {
  // type.args is a non-empty array
  const firstArg = type.args[0];
}
```

### Call Signature

```ts
function hasNonEmptyArrayProperty(
  obj,
  key,
): obj is Record<PropertyKey, unknown[]>;
```

Defined in: guards.ts:150

Type guard to check if an object has a non-empty array property.

#### Parameters

##### obj

`unknown`

The object to check

##### key

`PropertyKey`

The property name to look for

#### Returns

`obj is Record<PropertyKey, unknown[]>`

`true` if the property exists, is an array, and is non-empty, `false` otherwise

#### Example

```typescript

if (hasNonEmptyArrayProperty(type, "args")) {
  // type.args is a non-empty array
  const firstArg = type.args[0];
}
```

---

## hasProperties() \{#hasproperties\}

```ts
function hasProperties<K>(obj, ...keys): obj is Record<K, unknown>;
```

Defined in: guards.ts:82

Type guard to check if an object has multiple specific properties.

### Type Parameters

#### K

`K` _extends_ `PropertyKey`

### Parameters

#### obj

`unknown`

The object to check

#### keys

...`K`[]

The property names to look for

### Returns

`obj is Record<K, unknown>`

`true` if the object has all the properties, `false` otherwise

### Example

```typescript

if (hasProperties(type, "name", "description")) {
  // Both properties exist on type
  console.log(type.name, type.description);
}
```

---

## hasProperty() \{#hasproperty\}

### Call Signature

```ts
function hasProperty<K>(obj, key): obj is Record<K, unknown>;
```

Defined in: guards.ts:48

Type guard to check if an object has a specific property.

#### Type Parameters

##### K

`K` _extends_ `PropertyKey`

#### Parameters

##### obj

`unknown`

The object to check

##### key

`K`

The property name to look for

#### Returns

`obj is Record<K, unknown>`

`true` if the object has the property, `false` otherwise

#### Example

```typescript

if (hasProperty(type, "args")) {
  // type.args is now accessible
  console.log(type.args);
}
```

### Call Signature

```ts
function hasProperty(obj, key): obj is Record<PropertyKey, unknown>;
```

Defined in: guards.ts:53

Type guard to check if an object has a specific property.

#### Parameters

##### obj

`unknown`

The object to check

##### key

`PropertyKey`

The property name to look for

#### Returns

`obj is Record<PropertyKey, unknown>`

`true` if the object has the property, `false` otherwise

#### Example

```typescript

if (hasProperty(type, "args")) {
  // type.args is now accessible
  console.log(type.args);
}
```

---

## hasStringProperty() \{#hasstringproperty\}

### Call Signature

```ts
function hasStringProperty<K>(obj, key): obj is Record<K, string>;
```

Defined in: guards.ts:179

Type guard to check if an object has a string property.

#### Type Parameters

##### K

`K` _extends_ `PropertyKey`

#### Parameters

##### obj

`unknown`

The object to check

##### key

`K`

The property name to look for

#### Returns

`obj is Record<K, string>`

`true` if the property exists and is a string, `false` otherwise

#### Example

```typescript

if (hasStringProperty(type, "description")) {
  // type.description is now typed as string
  console.log(type.description.length);
}
```

### Call Signature

```ts
function hasStringProperty(obj, key): obj is Record<PropertyKey, string>;
```

Defined in: guards.ts:184

Type guard to check if an object has a string property.

#### Parameters

##### obj

`unknown`

The object to check

##### key

`PropertyKey`

The property name to look for

#### Returns

`obj is Record<PropertyKey, string>`

`true` if the property exists and is a string, `false` otherwise

#### Example

```typescript

if (hasStringProperty(type, "description")) {
  // type.description is now typed as string
  console.log(type.description.length);
}
```

---

## isNonEmptyArray() \{#isnonemptyarray\}

```ts
function isNonEmptyArray(value): value is unknown[];
```

Defined in: guards.ts:246

Type guard to check if a value is a non-empty array.

### Parameters

#### value

`unknown`

The value to check

### Returns

`value is unknown[]`

`true` if the value is an array with at least one element

### Example

```typescript

if (isNonEmptyArray(values)) {
  // values is now typed as unknown[] with at least one element
  console.log(values[0]);
}
```

---

## isTypeObject() \{#istypeobject\}

```ts
function isTypeObject(obj): obj is Record<string, unknown>;
```

Defined in: guards.ts:27

Type guard to check if a value is an object but not an array.

### Parameters

#### obj

`unknown`

The value to check

### Returns

`obj is Record<string, unknown>`

`true` if the value is a non-null object but not an array, `false` otherwise

### Example

```typescript

if (isTypeObject(value)) {
  // value is now typed as Record<string, unknown> and is not an array
  // (includes Date, Map, and other object types)
  console.log(Object.keys(value));
}
```

---

## markdown

Shared Markdown constants used across packages.

## FRONT_MATTER_DELIMITER \{#front_matter_delimiter\}

```ts
const FRONT_MATTER_DELIMITER: "---";
```

Defined in: markdown.ts:20

Frontmatter delimiter for YAML frontmatter blocks.

---

## MARKDOWN_CODE_INDENTATION \{#markdown_code_indentation\}

```ts
const MARKDOWN_CODE_INDENTATION: "  ";
```

Defined in: markdown.ts:30

Standard indentation for code blocks (2 spaces).

---

## MARKDOWN_CODE_SNIPPET \{#markdown_code_snippet\}

```ts
const MARKDOWN_CODE_SNIPPET: "``";
```

Defined in: markdown.ts:25

Code snippet delimiter for fenced code blocks.

---

## MARKDOWN_EOL \{#markdown_eol\}

```ts
const MARKDOWN_EOL: "\n";
```

Defined in: markdown.ts:10

End of line character for Markdown.

---

## MARKDOWN_EOP \{#markdown_eop\}

```ts
const MARKDOWN_EOP: string;
```

Defined in: markdown.ts:15

End of paragraph (double newline) for Markdown.

---

## object(Utils)

Internal library of helpers for manipulating objects.

## isEmpty() \{#isempty\}

```ts
function isEmpty<T>(obj): obj is Exclude<unknown, T>;
```

Defined in: object.ts:34

**`Internal`**

Check if an object contains key/value records.

### Type Parameters

#### T

`T` _extends_ `Record`&lt;`string`, `unknown`&gt;

### Parameters

#### obj

`unknown`

the key/value record object.

### Returns

`obj is Exclude<unknown, T>`

`false` if the object is a valid k/v set of records, else `true`.

### Example

```js

const obj = {
  bool: true,
  string: "test",
  number: 123,
  array: ["one", "two"],
  child: { key: "value" },
};

isEmpty(obj); // Returns false

isEmpty({}); // Returns true
```

---

## prettier

Internal library for prettifying files using `prettier`.

## prettify() \{#prettify\}

```ts
function prettify(content, parser): Promise<string | undefined>;
```

Defined in: prettier.ts:25

**`Internal`**

Prettify a string using

### Parameters

#### content

`string`

the string to be prettified.

#### parser

`string`

the `prettier` parser to use.

### Returns

`Promise`&lt;`string` \| `undefined`&gt;

a prettified string, or `undefined` if an error occurred.

### See

- [prettier.format](https://prettier.io/docs/en/api#prettierformatsource-options)
- [Prettier doc for the list of parsers](https://prettier.io/docs/en/options#parser)

### Remarks

This function logs a warning message on error.

---

## prettifyMarkdown() \{#prettifymarkdown\}

```ts
function prettifyMarkdown(content): Promise<string | undefined>;
```

Defined in: prettier.ts:67

**`Internal`**

Prettify a Markdown string using [prettify](#prettify) and `markdown` parser.

### Parameters

#### content

`string`

the string to be prettified.

### Returns

`Promise`&lt;`string` \| `undefined`&gt;

a prettified string, or `undefined` if an error occurred.

### Remarks

Same as `prettify(content, "mdx")`.

### See

[prettify](#prettify)

---

## string

Library of helpers for formatting strings.

## slugify \{#slugify\}

```ts
const slugify: (str) => string = kebabCase;
```

Defined in: string.ts:283

Returns a lowercase string with `-` as replacement for non alphanum characters using [stringCaseBuilder](#stringcasebuilder).

### Parameters

#### str

`Maybe`&lt;`string`&gt;

the string to be transformed.

### Returns

`string`

a string converted to start case, or an empty string if `str` is not a valid string.

### Example

```js

kebabCase("The quick brown Fox");
// Expected result: "the-quick-brown-fox"
```

---

## toString \{#tostring\}

```ts
const toString: StringConstructor = String;
```

Defined in: string.ts:293

Returns a stringified version of the variable.

### Param

the variable to be transformed.

### Returns

a string

---

## capitalize() \{#capitalize\}

```ts
function capitalize(str): string;
```

Defined in: string.ts:224

Returns a string in lowercase excepted for the 1st character capitalized using [firstUppercase](#firstuppercase).

### Parameters

#### str

`Maybe`&lt;`string`&gt;

the string to be transformed.

### Returns

`string`

a capitalized string, or an empty string if `str` is not a valid string.

### Example

```js

capitalize("the quick Brown Fox");
// Expected result: "The quick brown fox"
```

---

## escapeMDX() \{#escapemdx\}

```ts
function escapeMDX(str): string;
```

Defined in: string.ts:177

**`Internal`**

Returns a string with MDX special characters converted to HTML unicode using [toHTMLUnicode](#tohtmlunicode).
Characters within code notation should not be converted.
List of special characters: `{`, `<`, `>`, `}`

### Parameters

#### str

`unknown`

the string to be transformed.

### Returns

`string`

a string with MDX special characters replaced by HTML unicode equivalents.

### Example

```js

escapeMDX("{MDX} <special> characters");
// Expected result: "&#x007B;MDX&#x007D; &#x003C;special&#x003E; characters"

escapeMDX("`{MDX}` `<special>` characters");
// Expected result: "`{MDX}` `<special>` characters"
```

---

## firstUppercase() \{#firstuppercase\}

```ts
function firstUppercase(str): string;
```

Defined in: string.ts:200

Returns a string with the 1st character in uppercase.

### Parameters

#### str

`Maybe`&lt;`string`&gt;

the string to be transformed.

### Returns

`string`

a string with the 1st character in uppercase, or an empty string if `str` is not a valid string.

### Example

```js

firstUppercase("the quick Brown Fox");
// Expected result: "The quick Brown Fox"
```

---

## kebabCase() \{#kebabcase\}

```ts
function kebabCase(str): string;
```

Defined in: string.ts:267

Returns a lowercase string with `-` as replacement for non alphanum characters using [stringCaseBuilder](#stringcasebuilder).

### Parameters

#### str

`Maybe`&lt;`string`&gt;

the string to be transformed.

### Returns

`string`

a string converted to start case, or an empty string if `str` is not a valid string.

### Example

```js

kebabCase("The quick brown Fox");
// Expected result: "the-quick-brown-fox"
```

---

## prune() \{#prune\}

```ts
function prune(str, substr?): string;
```

Defined in: string.ts:58

**`Internal`**

Returns a string pruned on both start and end, similar to `trim()` but with any substring.

### Parameters

#### str

`Maybe`&lt;`string`&gt;

the string to be pruned.

#### substr?

`string` = `""`

the substring to be removed from `str`.

### Returns

`string`

a pruned string, or an empty string if `str` is not a valid string.

### Example

```js

const text = "**The quick brown fox jumps over the lazy dog.**";

prune(text, "**");
// Expected result: "The quick brown fox jumps over the lazy dog."
```

---

## replaceDiacritics() \{#replacediacritics\}

```ts
function replaceDiacritics(str): string;
```

Defined in: string.ts:27

Replaces diacritics by non-diacritic equivalent characters.

### Parameters

#### str

`Maybe`&lt;`string`&gt;

the string to be transformed.

### Returns

`string`

a string with diacritic characters replaced, or an empty string if `str` is not a valid string.

-

### Example

```js

replaceDiacritics("Âéêś"); // Expected result: "Aees"
```

### See

[StackOverflow source](https://stackoverflow.com/a/37511463)

---

## startCase() \{#startcase\}

```ts
function startCase(str): string;
```

Defined in: string.ts:246

Applies [firstUppercase](#firstuppercase) using [stringCaseBuilder](#stringcasebuilder) to every word of a string with `space` character as separator.

### Parameters

#### str

`Maybe`&lt;`string`&gt;

the string to be transformed.

### Returns

`string`

a string converted to start case, or an empty string if `str` is not a valid string.

### Example

```js

startCase("the quick Brown Fox");
// Expected result: "The Quick Brown Fox"
```

---

## stringCaseBuilder() \{#stringcasebuilder\}

```ts
function stringCaseBuilder(str, transformation?, separator?, splitter?): string;
```

Defined in: string.ts:100

**`Internal`**

Returns a string after applying a transformation function.
By default `splitter` expression will split the string into words, where non-alphanum chars are considered as word separators.
`separator` will be used for joining the words back together.
[prune](#prune) using `separator` is applied to the result of the transformation.

### Parameters

#### str

`Maybe`&lt;`string`&gt;

the string to be transformed.

#### transformation?

`Maybe`&lt;(`word`) => `string`&gt;

optional transformation callback function.

#### separator?

`string`

optional character separator for word-based transformation.

#### splitter?

`string` \| `RegExp`

optional regex or string rule for splitting string into word.

### Returns

`string`

a transformed string, or an empty string if `str` is not a valid string.

### Example

```js

const text = "The quick brown fox jumps over the lazy dog.";
const transformation = (word: string): string => `*${word}*`

stringCaseBuilder(text, transformation, " ");
// Expected result: "*The* *quick* *brown* *fox* *jumps* *over* *the* *lazy* *dog*"
```

---

## toHTMLUnicode() \{#tohtmlunicode\}

```ts
function toHTMLUnicode(char): string;
```

Defined in: string.ts:146

**`Internal`**

Converts a character to its equivalent HTML unicode representation `&#x0000`.

### Parameters

#### char

`Maybe`&lt;`string`&gt;

the character to be transformed.

### Returns

`string`

a HTML unicode representation of `char`, or an empty string if `char` is not a valid string.

### Example

```js

toHTMLUnicode("%"); // Expected result: "&#x0025;"
```

---

## url

Alias `path.posix` to normalize URL handling on Windows.