@enjoys/context-engine 1.3.1 → 1.4.2

package/data/hover/mdx.json

@@ -4,35 +4,280 @@
     "import": {
       "contents": [
         {
-          "value": "**import** — MDX keyword."
+          "value": "```mdx\nimport { Button } from './components/Button'\nimport Chart from './Chart'\n```\n**import** brings JavaScript/React components into MDX. Must appear at the top of the file."
         }
       ]
     },
     "export": {
       "contents": [
         {
-          "value": "**export** — MDX keyword."
+          "value": "```mdx\nexport const metadata = { title: 'My Post' }\n\nexport default function Layout({ children }) {\n  return <article>{children}</article>\n}\n```\n**export** exposes values from MDX. `export default` sets a wrapper layout component."
         }
       ]
     },
     "default": {
       "contents": [
         {
-          "value": "**default** — MDX keyword."
+          "value": "```mdx\nexport default function Layout({ children }) {\n  return <div className=\"prose\">{children}</div>\n}\n```\n**export default** defines the layout wrapper. MDX content is passed as `children`."
         }
       ]
     },
     "from": {
       "contents": [
         {
-          "value": "**from** — MDX keyword."
+          "value": "```mdx\nimport { useState } from 'react'\nimport styles from './page.module.css'\n```\n**from** specifies the module path: npm packages, relative paths, or aliased paths."
         }
       ]
     },
     "as": {
       "contents": [
         {
-          "value": "**as** — MDX keyword."
+          "value": "```mdx\nimport { Button as PrimaryButton } from './components'\nimport * as Icons from './icons'\n```\n**as** renames an import binding to avoid naming conflicts."
+        }
+      ]
+    },
+    "JSX": {
+      "contents": [
+        {
+          "value": "```mdx\n# My Article\n\nSome markdown text.\n\n<Button variant=\"primary\" onClick={() => alert('clicked')}>\n  Click me\n</Button>\n```\n**JSX** can be used inline with Markdown in MDX. Components must be imported or provided via MDXProvider."
+        }
+      ]
+    },
+    "expression": {
+      "contents": [
+        {
+          "value": "```mdx\n# Hello {name}\n\nThe result is {2 + 2}.\n\nToday is {new Date().toLocaleDateString()}.\n```\n**Expressions** in `{}` embed JavaScript values and logic inline. Supports variables, arithmetic, and conditionals."
+        }
+      ]
+    },
+    "frontmatter": {
+      "contents": [
+        {
+          "value": "```mdx\n---\ntitle: Getting Started\ndescription: Learn MDX basics\nauthor: Jane Doe\ndate: 2024-01-15\n---\n```\n**Frontmatter** is YAML metadata between `---` delimiters at the top of the file."
+        }
+      ]
+    },
+    "MDXProvider": {
+      "contents": [
+        {
+          "value": "```jsx\nimport { MDXProvider } from '@mdx-js/react'\n\nconst components = {\n  h1: props => <h1 className=\"title\" {...props} />,\n  code: CodeBlock,\n  a: CustomLink\n}\n\n<MDXProvider components={components}>{children}</MDXProvider>\n```\n**MDXProvider** supplies custom components that replace default HTML elements in MDX."
+        }
+      ]
+    },
+    "components": {
+      "contents": [
+        {
+          "value": "```mdx\nimport { Tabs, Tab } from './Tabs'\nimport { Callout } from './Callout'\n\n<Callout type=\"warning\">\n  This is important!\n</Callout>\n```\n**Components** are React elements used directly in MDX for interactive, reusable content blocks."
+        }
+      ]
+    },
+    "heading": {
+      "contents": [
+        {
+          "value": "```mdx\n# H1 Title\n## H2 Section\n### H3 Subsection\n## Dynamic {version}\n```\n**Headings** use standard Markdown `#` syntax. Can contain JSX expressions in MDX."
+        }
+      ]
+    },
+    "code_block": {
+      "contents": [
+        {
+          "value": "````mdx\n```javascript title=\"example.js\" {3-4} showLineNumbers\nfunction hello() {\n  console.log('Hello')\n}\n```\n````\n**Code blocks** use triple backticks with optional language, title, and line highlighting meta."
+        }
+      ]
+    },
+    "inline_code": {
+      "contents": [
+        {
+          "value": "```mdx\nUse the `useState` hook for state management.\n```\n**Inline code** uses single backticks. Can be customized via MDXProvider."
+        }
+      ]
+    },
+    "link": {
+      "contents": [
+        {
+          "value": "```mdx\n[External link](https://example.com)\n[Internal link](/docs/getting-started)\n```\n**Links** use standard Markdown syntax. Internal links are handled by framework routers."
+        }
+      ]
+    },
+    "image": {
+      "contents": [
+        {
+          "value": "```mdx\n![Alt text](./image.png)\n\nimport screenshot from './screenshot.png'\n<img src={screenshot} alt=\"Screenshot\" width={600} />\n```\n**Images** use Markdown `![]()` or JSX `<img>`. Import images for bundler optimization."
+        }
+      ]
+    },
+    "table": {
+      "contents": [
+        {
+          "value": "```mdx\n| Feature | Supported |\n|---------|:---------:|\n| Markdown | Yes |\n| JSX | Yes |\n```\n**Tables** use pipe-delimited Markdown syntax. Colon placement controls alignment."
+        }
+      ]
+    },
+    "list": {
+      "contents": [
+        {
+          "value": "```mdx\n- Item one\n  - Nested item\n1. First step\n- [ ] Todo incomplete\n- [x] Todo complete\n```\n**Lists** support unordered, ordered, and task list syntax. Can contain JSX as list items."
+        }
+      ]
+    },
+    "blockquote": {
+      "contents": [
+        {
+          "value": "```mdx\n> Standard blockquote text.\n> > Nested quote\n```\n**Blockquotes** use `>` prefix. Consider custom Callout components for better styling."
+        }
+      ]
+    },
+    "emphasis": {
+      "contents": [
+        {
+          "value": "```mdx\n*italic* or _italic_\n**bold** or __bold__\n***bold italic***\n~~strikethrough~~\n```\n**Text emphasis** uses standard Markdown formatting syntax."
+        }
+      ]
+    },
+    "hr": {
+      "contents": [
+        {
+          "value": "```mdx\n---\n```\n**Horizontal rule** creates a thematic break. Must have blank lines before and after."
+        }
+      ]
+    },
+    "comment": {
+      "contents": [
+        {
+          "value": "```mdx\n{/* This is an MDX comment */}\n{/* It won't appear in the output */}\n```\n**Comments** use JSX syntax `{/* */}`. Preferred over HTML comments."
+        }
+      ]
+    },
+    "useState": {
+      "contents": [
+        {
+          "value": "```mdx\nimport { useState } from 'react'\n\nexport const Counter = () => {\n  const [count, setCount] = useState(0)\n  return <button onClick={() => setCount(c => c + 1)}>Count: {count}</button>\n}\n\n<Counter />\n```\n**useState** enables interactive state in MDX documents."
+        }
+      ]
+    },
+    "props": {
+      "contents": [
+        {
+          "value": "```mdx\nexport default function Layout({ children, ...props }) {\n  return <article><h1>{props.title}</h1>{children}</article>\n}\n```\n**Props** are passed to MDX documents by the rendering framework."
+        }
+      ]
+    },
+    "remark_plugins": {
+      "contents": [
+        {
+          "value": "```javascript\n{\n  remarkPlugins: [remarkGfm, remarkMath, remarkToc],\n  rehypePlugins: [rehypeSlug, rehypeHighlight]\n}\n```\n**Plugins** extend MDX processing. Remark transforms Markdown AST, rehype transforms HTML AST."
+        }
+      ]
+    },
+    "math": {
+      "contents": [
+        {
+          "value": "```mdx\nInline math: $E = mc^2$\n\n$$\n\\sum_{i=1}^{n} x_i\n$$\n```\n**Math** support requires `remark-math` and `rehype-katex` plugins. Uses LaTeX syntax."
+        }
+      ]
+    },
+    "GFM": {
+      "contents": [
+        {
+          "value": "```mdx\n~~strikethrough~~\nhttps://auto.link\n- [x] task list\n| table | support |\n```\n**GFM** (GitHub Flavored Markdown) adds autolinks, tables, task lists, strikethrough. Enable with `remark-gfm`."
+        }
+      ]
+    },
+    "Tabs": {
+      "contents": [
+        {
+          "value": "```mdx\nimport { Tabs, Tab } from 'nextra/components'\n\n<Tabs items={['npm', 'yarn', 'pnpm']}>\n  <Tab>npm install package</Tab>\n  <Tab>yarn add package</Tab>\n  <Tab>pnpm add package</Tab>\n</Tabs>\n```\n**Tabs** component shows switchable panels for alternatives."
+        }
+      ]
+    },
+    "Steps": {
+      "contents": [
+        {
+          "value": "```mdx\nimport { Steps } from 'nextra/components'\n\n<Steps>\n### Install dependencies\nnpm install mdx\n### Create your first file\nCreate hello.mdx\n</Steps>\n```\n**Steps** renders numbered step-by-step instructions."
+        }
+      ]
+    },
+    "Callout": {
+      "contents": [
+        {
+          "value": "```mdx\nimport { Callout } from 'nextra/components'\n\n<Callout type=\"warning\">\n  Be careful with this operation.\n</Callout>\n```\n**Callout** displays styled admonition blocks: `info`, `warning`, `error`, `default`."
+        }
+      ]
+    },
+    "Cards": {
+      "contents": [
+        {
+          "value": "```mdx\nimport { Cards, Card } from 'nextra/components'\n\n<Cards>\n  <Card title=\"Getting Started\" href=\"/docs/start\" />\n  <Card title=\"API Reference\" href=\"/docs/api\" />\n</Cards>\n```\n**Cards** renders a grid of navigation cards for landing pages."
+        }
+      ]
+    },
+    "FileTree": {
+      "contents": [
+        {
+          "value": "```mdx\nimport { FileTree } from 'nextra/components'\n\n<FileTree>\n  <FileTree.Folder name=\"src\" defaultOpen>\n    <FileTree.File name=\"index.ts\" />\n  </FileTree.Folder>\n</FileTree>\n```\n**FileTree** renders an interactive file/folder tree visualization."
+        }
+      ]
+    },
+    "remarkGfm": {
+      "contents": [
+        {
+          "value": "```javascript\nimport remarkGfm from 'remark-gfm'\n\nexport default {\n  remarkPlugins: [remarkGfm]\n}\n```\n**remark-gfm** enables GitHub Flavored Markdown: tables, task lists, autolinks, strikethrough, footnotes."
+        }
+      ]
+    },
+    "next_mdx": {
+      "contents": [
+        {
+          "value": "```javascript\nimport createMDX from '@next/mdx'\nconst withMDX = createMDX({\n  extension: /\\.mdx?$/,\n  options: { remarkPlugins: [], rehypePlugins: [] }\n})\nexport default withMDX({ pageExtensions: ['md', 'mdx', 'tsx'] })\n```\n**@next/mdx** integrates MDX with Next.js. MDX files become routes."
+        }
+      ]
+    },
+    "compile": {
+      "contents": [
+        {
+          "value": "```javascript\nimport { compile } from '@mdx-js/mdx'\nconst code = await compile('# Hello', {\n  outputFormat: 'function-body'\n})\n```\n**compile** transforms MDX source into JavaScript."
+        }
+      ]
+    },
+    "evaluate": {
+      "contents": [
+        {
+          "value": "```javascript\nimport { evaluate } from '@mdx-js/mdx'\nimport * as runtime from 'react/jsx-runtime'\nconst { default: Content } = await evaluate('# Hello', runtime)\n```\n**evaluate** compiles and runs MDX at runtime. Useful for CMS or dynamic content."
+        }
+      ]
+    },
+    "useMDXComponents": {
+      "contents": [
+        {
+          "value": "```typescript\nimport type { MDXComponents } from 'mdx/types'\nexport function useMDXComponents(components: MDXComponents) {\n  return {\n    h1: ({ children }) => <h1 className=\"text-4xl\">{children}</h1>,\n    ...components\n  }\n}\n```\n**useMDXComponents** (Next.js) customizes MDX element rendering globally."
+        }
+      ]
+    },
+    "directive": {
+      "contents": [
+        {
+          "value": "```mdx\n:::note\nThis is a note directive.\n:::\n\n:::tip[Custom title]\nHelpful tip here.\n:::\n```\n**Directives** (via `remark-directive`) add container blocks. Used by Docusaurus."
+        }
+      ]
+    },
+    "toc": {
+      "contents": [
+        {
+          "value": "```mdx\nimport { TOC } from './components/TOC'\n<TOC />\n\n## Introduction\n## Getting Started\n```\n**Table of Contents** can be auto-generated from headings or rendered with custom components."
+        }
+      ]
+    },
+    "embed": {
+      "contents": [
+        {
+          "value": "```mdx\n<iframe src=\"https://codesandbox.io/embed/example\" width=\"100%\" height=\"500\" />\n\nimport { YouTube } from './components/YouTube'\n<YouTube id=\"dQw4w9WgXcQ\" />\n```\n**Embeds** use JSX to include iframes, videos, or interactive demos."
+        }
+      ]
+    },
+    "aside": {
+      "contents": [
+        {
+          "value": "```mdx\nimport { Aside } from './components/Aside'\n\n<Aside>\n  **Related:** See the [config guide](/docs/config).\n</Aside>\n```\n**Aside** renders supplementary content as a sidebar or margin note."
         }
       ]
     }

package/data/hover/nestjs.json

@@ -0,0 +1,296 @@
+{
+  "language": "nestjs",
+  "hovers": {
+    "@Controller": {
+      "contents": [{ "value": "```typescript\nfunction Controller(prefix?: string | string[]): ClassDecorator\n```\nMarks a class as a NestJS controller. Accepts an optional route path prefix or array of prefixes. Controllers handle incoming HTTP requests and return responses." }]
+    },
+    "@Get": {
+      "contents": [{ "value": "```typescript\nfunction Get(path?: string | string[]): MethodDecorator\n```\nRoutes HTTP GET requests to the decorated method. Accepts an optional route path. Used to retrieve resources." }]
+    },
+    "@Post": {
+      "contents": [{ "value": "```typescript\nfunction Post(path?: string | string[]): MethodDecorator\n```\nRoutes HTTP POST requests to the decorated method. Used to create new resources." }]
+    },
+    "@Put": {
+      "contents": [{ "value": "```typescript\nfunction Put(path?: string | string[]): MethodDecorator\n```\nRoutes HTTP PUT requests to the decorated method. Used to replace an entire resource." }]
+    },
+    "@Patch": {
+      "contents": [{ "value": "```typescript\nfunction Patch(path?: string | string[]): MethodDecorator\n```\nRoutes HTTP PATCH requests to the decorated method. Used to partially update a resource." }]
+    },
+    "@Delete": {
+      "contents": [{ "value": "```typescript\nfunction Delete(path?: string | string[]): MethodDecorator\n```\nRoutes HTTP DELETE requests to the decorated method. Used to remove a resource." }]
+    },
+    "@Module": {
+      "contents": [{ "value": "```typescript\nfunction Module(metadata: ModuleMetadata): ClassDecorator\n```\nMarks a class as a NestJS module. Accepts metadata object with `imports`, `controllers`, `providers`, and `exports` arrays. Modules organize the application structure." }]
+    },
+    "@Injectable": {
+      "contents": [{ "value": "```typescript\nfunction Injectable(options?: InjectableOptions): ClassDecorator\n```\nMarks a class as a provider that can be managed by the NestJS IoC container. Enables dependency injection for services, guards, pipes, interceptors, etc." }]
+    },
+    "@Inject": {
+      "contents": [{ "value": "```typescript\nfunction Inject(token?: string | symbol | Type): ParameterDecorator\n```\nInjects a provider by token. Used for non-class-based (custom) provider injection, such as string or symbol tokens." }]
+    },
+    "@Optional": {
+      "contents": [{ "value": "```typescript\nfunction Optional(): ParameterDecorator\n```\nMarks a constructor parameter as optional. Prevents errors when the injected provider is not available in the current scope." }]
+    },
+    "@Body": {
+      "contents": [{ "value": "```typescript\nfunction Body(property?: string): ParameterDecorator\n```\nExtracts the request body or a specific property from it. When a property key is provided, only that nested value is extracted." }]
+    },
+    "@Param": {
+      "contents": [{ "value": "```typescript\nfunction Param(property?: string): ParameterDecorator\n```\nExtracts a route parameter or all route parameters from the request URL path." }]
+    },
+    "@Query": {
+      "contents": [{ "value": "```typescript\nfunction Query(property?: string): ParameterDecorator\n```\nExtracts query string parameters from the request URL. Optionally extracts a single named query parameter." }]
+    },
+    "@Headers": {
+      "contents": [{ "value": "```typescript\nfunction Headers(property?: string): ParameterDecorator\n```\nExtracts headers from the request. When a header name is provided, returns only that header's value." }]
+    },
+    "@Req": {
+      "contents": [{ "value": "```typescript\nfunction Req(): ParameterDecorator\n```\nInjects the underlying platform request object (e.g., Express Request). Provides full access to the raw request." }]
+    },
+    "@Res": {
+      "contents": [{ "value": "```typescript\nfunction Res(options?: { passthrough?: boolean }): ParameterDecorator\n```\nInjects the underlying platform response object. Note: using `@Res()` disables NestJS standard response handling unless `{ passthrough: true }` is set." }]
+    },
+    "@HttpCode": {
+      "contents": [{ "value": "```typescript\nfunction HttpCode(statusCode: number): MethodDecorator\n```\nSets the HTTP response status code for the decorated route handler. By default, POST returns 201 and other methods return 200." }]
+    },
+    "@Header": {
+      "contents": [{ "value": "```typescript\nfunction Header(name: string, value: string): MethodDecorator\n```\nSets a custom response header for the decorated route handler." }]
+    },
+    "@Redirect": {
+      "contents": [{ "value": "```typescript\nfunction Redirect(url?: string, statusCode?: number): MethodDecorator\n```\nRedirects the response to the given URL. Default status code is 302 (Found)." }]
+    },
+    "@Render": {
+      "contents": [{ "value": "```typescript\nfunction Render(template: string): MethodDecorator\n```\nRenders a view template using the configured template engine (e.g., Handlebars, Pug, EJS)." }]
+    },
+    "@UseGuards": {
+      "contents": [{ "value": "```typescript\nfunction UseGuards(...guards: (CanActivate | Function)[]): MethodDecorator & ClassDecorator\n```\nBinds guards to the scope of the controller or method. Guards determine whether a request should be handled by the route handler." }]
+    },
+    "@UseInterceptors": {
+      "contents": [{ "value": "```typescript\nfunction UseInterceptors(...interceptors: (NestInterceptor | Function)[]): MethodDecorator & ClassDecorator\n```\nBinds interceptors to the controller or method scope. Interceptors can transform the result, handle errors, extend behavior, or override methods." }]
+    },
+    "@UsePipes": {
+      "contents": [{ "value": "```typescript\nfunction UsePipes(...pipes: (PipeTransform | Function)[]): MethodDecorator & ClassDecorator\n```\nBinds pipes to the controller or method scope. Pipes transform input data or validate it before the handler is called." }]
+    },
+    "@UseFilters": {
+      "contents": [{ "value": "```typescript\nfunction UseFilters(...filters: (ExceptionFilter | Function)[]): MethodDecorator & ClassDecorator\n```\nBinds exception filters to the controller or method scope. Filters handle exceptions thrown during request processing." }]
+    },
+    "@SetMetadata": {
+      "contents": [{ "value": "```typescript\nfunction SetMetadata(key: string, value: any): CustomDecorator\n```\nAttaches custom metadata to a route handler, accessible via the `Reflector` class in guards and interceptors." }]
+    },
+    "@Catch": {
+      "contents": [{ "value": "```typescript\nfunction Catch(...exceptions: Type[]): ClassDecorator\n```\nMarks a class as an exception filter for the given exception type(s). The class must implement `ExceptionFilter`." }]
+    },
+    "@EventPattern": {
+      "contents": [{ "value": "```typescript\nfunction EventPattern(metadata: any): MethodDecorator\n```\nSubscribes to an event-based microservice pattern (fire-and-forget). The handler does not return a response to the sender." }]
+    },
+    "@MessagePattern": {
+      "contents": [{ "value": "```typescript\nfunction MessagePattern(metadata: any): MethodDecorator\n```\nSubscribes to a request-response microservice message pattern. The handler returns a response to the sender." }]
+    },
+    "@WebSocketGateway": {
+      "contents": [{ "value": "```typescript\nfunction WebSocketGateway(options?: GatewayMetadata): ClassDecorator\n```\nMarks a class as a WebSocket gateway. Accepts optional configuration for port, namespace, and CORS settings." }]
+    },
+    "@SubscribeMessage": {
+      "contents": [{ "value": "```typescript\nfunction SubscribeMessage(message: string): MethodDecorator\n```\nSubscribes to a specific WebSocket message event. The decorated method handles incoming messages matching the event name." }]
+    },
+    "@ConnectedSocket": {
+      "contents": [{ "value": "```typescript\nfunction ConnectedSocket(): ParameterDecorator\n```\nInjects the connected client socket instance into a gateway method parameter." }]
+    },
+    "@WebSocketServer": {
+      "contents": [{ "value": "```typescript\nfunction WebSocketServer(): PropertyDecorator\n```\nInjects the underlying WebSocket server instance (e.g., Socket.IO Server) as a class property." }]
+    },
+    "@Sse": {
+      "contents": [{ "value": "```typescript\nfunction Sse(path?: string): MethodDecorator\n```\nMarks a method as a Server-Sent Events endpoint. The method should return an Observable that emits MessageEvent objects." }]
+    },
+    "@Cron": {
+      "contents": [{ "value": "```typescript\nfunction Cron(cronTime: string | CronExpression, options?: CronOptions): MethodDecorator\n```\nSchedules a method to run based on a cron expression. Requires `@nestjs/schedule` and `ScheduleModule.forRoot()`." }]
+    },
+    "@Interval": {
+      "contents": [{ "value": "```typescript\nfunction Interval(timeout: number): MethodDecorator\n```\nSchedules a method to run repeatedly at a fixed interval (in milliseconds). Requires `@nestjs/schedule`." }]
+    },
+    "@Timeout": {
+      "contents": [{ "value": "```typescript\nfunction Timeout(timeout: number): MethodDecorator\n```\nSchedules a method to run once after a specified timeout (in milliseconds). Requires `@nestjs/schedule`." }]
+    },
+    "@ApiTags": {
+      "contents": [{ "value": "```typescript\nfunction ApiTags(...tags: string[]): ClassDecorator & MethodDecorator\n```\nAdds tags to Swagger documentation for grouping and organizing API endpoints." }]
+    },
+    "@ApiOperation": {
+      "contents": [{ "value": "```typescript\nfunction ApiOperation(options: ApiOperationOptions): MethodDecorator\n```\nDescribes an API operation for Swagger documentation. Accepts summary, description, and other metadata." }]
+    },
+    "@ApiResponse": {
+      "contents": [{ "value": "```typescript\nfunction ApiResponse(options: ApiResponseOptions): MethodDecorator & ClassDecorator\n```\nDocuments an API response with status code, description, and optional type for Swagger." }]
+    },
+    "@ApiProperty": {
+      "contents": [{ "value": "```typescript\nfunction ApiProperty(options?: ApiPropertyOptions): PropertyDecorator\n```\nDecorates a DTO property for Swagger schema documentation. Defines type, description, example, and validation constraints." }]
+    },
+    "@ApiBody": {
+      "contents": [{ "value": "```typescript\nfunction ApiBody(options: ApiBodyOptions): MethodDecorator\n```\nDescribes the request body schema for Swagger documentation, including type and content type." }]
+    },
+    "@ApiBearerAuth": {
+      "contents": [{ "value": "```typescript\nfunction ApiBearerAuth(name?: string): ClassDecorator & MethodDecorator\n```\nMarks an endpoint as requiring Bearer token authentication in Swagger UI. Adds the lock icon." }]
+    },
+    "NestFactory": {
+      "contents": [{ "value": "```typescript\nclass NestFactory {\n  static create(module: any, options?: NestApplicationOptions): Promise<INestApplication>\n  static createMicroservice(module: any, options?: MicroserviceOptions): Promise<INestMicroservice>\n}\n```\nFactory class to create NestJS application and microservice instances. Entry point for bootstrapping." }]
+    },
+    "INestApplication": {
+      "contents": [{ "value": "```typescript\ninterface INestApplication extends INestApplicationContext\n```\nInterface for the NestJS HTTP application instance. Provides methods like `listen()`, `use()`, `useGlobalPipes()`, `enableCors()`, `setGlobalPrefix()`, and more." }]
+    },
+    "ModuleRef": {
+      "contents": [{ "value": "```typescript\nclass ModuleRef extends AbstractInstanceResolver\n```\nProvides access to the internal provider container for dynamic provider resolution. Use `get()` for singletons, `resolve()` for transient/request-scoped providers." }]
+    },
+    "Reflector": {
+      "contents": [{ "value": "```typescript\nclass Reflector {\n  get<T>(metadataKey: any, target: Function): T\n  getAllAndOverride<T>(metadataKey: any, targets: Function[]): T\n  getAllAndMerge<T>(metadataKey: any, targets: Function[]): T\n}\n```\nHelper class to retrieve metadata set via `@SetMetadata()`. Commonly used in guards and interceptors." }]
+    },
+    "ConfigModule": {
+      "contents": [{ "value": "```typescript\nclass ConfigModule {\n  static forRoot(options?: ConfigModuleOptions): DynamicModule\n}\n```\nModule for loading environment variables and configuration. Set `isGlobal: true` to make it available everywhere without importing." }]
+    },
+    "ConfigService": {
+      "contents": [{ "value": "```typescript\nclass ConfigService {\n  get<T>(propertyPath: string, defaultValue?: T): T | undefined\n  getOrThrow<T>(propertyPath: string): T\n}\n```\nService to access configuration values loaded by ConfigModule. Supports nested paths and typed returns." }]
+    },
+    "TypeOrmModule": {
+      "contents": [{ "value": "```typescript\nclass TypeOrmModule {\n  static forRoot(options?: TypeOrmModuleOptions): DynamicModule\n  static forFeature(entities: EntityClassOrSchema[]): DynamicModule\n}\n```\nModule for integrating TypeORM with NestJS. Use `forRoot()` for database connection and `forFeature()` to register repositories." }]
+    },
+    "MongooseModule": {
+      "contents": [{ "value": "```typescript\nclass MongooseModule {\n  static forRoot(uri: string, options?: MongooseModuleOptions): DynamicModule\n  static forFeature(models: ModelDefinition[]): DynamicModule\n}\n```\nModule for integrating Mongoose ODM with NestJS. Use `forRoot()` for connection and `forFeature()` to register schemas." }]
+    },
+    "JwtModule": {
+      "contents": [{ "value": "```typescript\nclass JwtModule {\n  static register(options: JwtModuleOptions): DynamicModule\n  static registerAsync(options: JwtModuleAsyncOptions): DynamicModule\n}\n```\nModule for JWT token generation and verification. Provides JwtService for signing and verifying tokens." }]
+    },
+    "PassportModule": {
+      "contents": [{ "value": "```typescript\nclass PassportModule {\n  static register(options?: AuthModuleOptions): DynamicModule\n}\n```\nModule for integrating Passport.js authentication strategies with NestJS." }]
+    },
+    "ThrottlerModule": {
+      "contents": [{ "value": "```typescript\nclass ThrottlerModule {\n  static forRoot(options?: ThrottlerModuleOptions): DynamicModule\n}\n```\nRate limiting module to protect endpoints from brute-force attacks. Configure TTL and limit per time window." }]
+    },
+    "CacheModule": {
+      "contents": [{ "value": "```typescript\nclass CacheModule {\n  static register(options?: CacheModuleOptions): DynamicModule\n}\n```\nModule for caching responses. Supports in-memory caching and external stores like Redis." }]
+    },
+    "ScheduleModule": {
+      "contents": [{ "value": "```typescript\nclass ScheduleModule {\n  static forRoot(): DynamicModule\n}\n```\nModule for task scheduling. Enables `@Cron()`, `@Interval()`, and `@Timeout()` decorators for scheduled tasks." }]
+    },
+    "BullModule": {
+      "contents": [{ "value": "```typescript\nclass BullModule {\n  static forRoot(options?: BullRootModuleOptions): DynamicModule\n  static registerQueue(...options: BullModuleOptions[]): DynamicModule\n}\n```\nModule for queue management using Bull and Redis for background job processing." }]
+    },
+    "EventEmitterModule": {
+      "contents": [{ "value": "```typescript\nclass EventEmitterModule {\n  static forRoot(options?: EventEmitterModuleOptions): DynamicModule\n}\n```\nModule for event-driven architecture using Node.js EventEmitter. Enables `@OnEvent()` decorator." }]
+    },
+    "ServeStaticModule": {
+      "contents": [{ "value": "```typescript\nclass ServeStaticModule {\n  static forRoot(...options: ServeStaticModuleOptions[]): DynamicModule\n}\n```\nModule for serving static files (SPA, assets) from a directory alongside the API." }]
+    },
+    "GraphQLModule": {
+      "contents": [{ "value": "```typescript\nclass GraphQLModule {\n  static forRoot<T>(options: T): DynamicModule\n}\n```\nModule for integrating GraphQL with NestJS. Supports code-first and schema-first approaches with Apollo or Mercurius." }]
+    },
+    "ValidationPipe": {
+      "contents": [{ "value": "```typescript\nclass ValidationPipe implements PipeTransform\n```\nPipe that validates incoming data using class-validator decorators. Options include `whitelist`, `transform`, `forbidNonWhitelisted`, and `disableErrorMessages`." }]
+    },
+    "ParseIntPipe": {
+      "contents": [{ "value": "```typescript\nclass ParseIntPipe implements PipeTransform<string, number>\n```\nPipe that transforms a string parameter into an integer. Throws `BadRequestException` if the value cannot be parsed." }]
+    },
+    "ParseBoolPipe": {
+      "contents": [{ "value": "```typescript\nclass ParseBoolPipe implements PipeTransform<string, boolean>\n```\nPipe that transforms a string parameter into a boolean value. Accepts 'true' and 'false' strings." }]
+    },
+    "ParseArrayPipe": {
+      "contents": [{ "value": "```typescript\nclass ParseArrayPipe implements PipeTransform\n```\nPipe that parses and validates arrays. Supports item type validation via the `items` option." }]
+    },
+    "ParseUUIDPipe": {
+      "contents": [{ "value": "```typescript\nclass ParseUUIDPipe implements PipeTransform<string, string>\n```\nPipe that validates a string parameter is a valid UUID. Supports UUID versions 3, 4, and 5." }]
+    },
+    "ParseEnumPipe": {
+      "contents": [{ "value": "```typescript\nclass ParseEnumPipe<T> implements PipeTransform<string, T>\n```\nPipe that validates a parameter is a valid value of the given enum type." }]
+    },
+    "DefaultValuePipe": {
+      "contents": [{ "value": "```typescript\nclass DefaultValuePipe<T> implements PipeTransform\n```\nPipe that provides a default value when the parameter is null or undefined." }]
+    },
+    "ParseFloatPipe": {
+      "contents": [{ "value": "```typescript\nclass ParseFloatPipe implements PipeTransform<string, number>\n```\nPipe that transforms a string parameter into a floating-point number. Throws `BadRequestException` on failure." }]
+    },
+    "AuthGuard": {
+      "contents": [{ "value": "```typescript\nfunction AuthGuard(type?: string | string[]): Type<CanActivate>\n```\nGuard factory that triggers Passport authentication for a given strategy (e.g., 'jwt', 'local'). Returns a guard class." }]
+    },
+    "ClassSerializerInterceptor": {
+      "contents": [{ "value": "```typescript\nclass ClassSerializerInterceptor implements NestInterceptor\n```\nInterceptor that serializes response objects using class-transformer. Respects `@Exclude()` and `@Expose()` decorators on entity/DTO classes." }]
+    },
+    "CacheInterceptor": {
+      "contents": [{ "value": "```typescript\nclass CacheInterceptor implements NestInterceptor\n```\nInterceptor that automatically caches GET responses. Works with CacheModule. Configurable TTL and cache key." }]
+    },
+    "FileInterceptor": {
+      "contents": [{ "value": "```typescript\nfunction FileInterceptor(fieldName: string, localOptions?: MulterOptions): Type<NestInterceptor>\n```\nInterceptor for handling single file uploads via multipart/form-data using Multer. Use with `@UploadedFile()` decorator." }]
+    },
+    "FilesInterceptor": {
+      "contents": [{ "value": "```typescript\nfunction FilesInterceptor(fieldName: string, maxCount?: number, localOptions?: MulterOptions): Type<NestInterceptor>\n```\nInterceptor for handling multiple file uploads via multipart/form-data using Multer. Use with `@UploadedFiles()` decorator." }]
+    },
+    "HttpException": {
+      "contents": [{ "value": "```typescript\nclass HttpException extends Error {\n  constructor(response: string | Record<string, any>, status: number)\n  getStatus(): number\n  getResponse(): string | object\n}\n```\nBase class for all HTTP exceptions in NestJS. All built-in HTTP exceptions extend this class." }]
+    },
+    "BadRequestException": {
+      "contents": [{ "value": "```typescript\nclass BadRequestException extends HttpException\n```\nThrows a 400 Bad Request HTTP exception. Used when the server cannot process the request due to client error." }]
+    },
+    "UnauthorizedException": {
+      "contents": [{ "value": "```typescript\nclass UnauthorizedException extends HttpException\n```\nThrows a 401 Unauthorized HTTP exception. Used when authentication is required and has failed or not been provided." }]
+    },
+    "ForbiddenException": {
+      "contents": [{ "value": "```typescript\nclass ForbiddenException extends HttpException\n```\nThrows a 403 Forbidden HTTP exception. Used when the user is authenticated but lacks permission." }]
+    },
+    "NotFoundException": {
+      "contents": [{ "value": "```typescript\nclass NotFoundException extends HttpException\n```\nThrows a 404 Not Found HTTP exception. Used when the requested resource does not exist." }]
+    },
+    "ConflictException": {
+      "contents": [{ "value": "```typescript\nclass ConflictException extends HttpException\n```\nThrows a 409 Conflict HTTP exception. Used when the request conflicts with the current state of the resource." }]
+    },
+    "InternalServerErrorException": {
+      "contents": [{ "value": "```typescript\nclass InternalServerErrorException extends HttpException\n```\nThrows a 500 Internal Server Error HTTP exception. Used for unexpected server-side errors." }]
+    },
+    "HttpStatus": {
+      "contents": [{ "value": "```typescript\nenum HttpStatus {\n  OK = 200, CREATED = 201, BAD_REQUEST = 400,\n  UNAUTHORIZED = 401, FORBIDDEN = 403, NOT_FOUND = 404, ...\n}\n```\nEnum containing standard HTTP status codes for use with `@HttpCode()` and `HttpException`." }]
+    },
+    "Logger": {
+      "contents": [{ "value": "```typescript\nclass Logger {\n  log(message: any, context?: string): void\n  error(message: any, trace?: string, context?: string): void\n  warn(message: any, context?: string): void\n  debug(message: any, context?: string): void\n  verbose(message: any, context?: string): void\n}\n```\nBuilt-in NestJS logger with multiple log levels. Can be replaced with a custom logger implementation." }]
+    },
+    "ExecutionContext": {
+      "contents": [{ "value": "```typescript\ninterface ExecutionContext extends ArgumentsHost {\n  getClass<T>(): Type<T>\n  getHandler(): Function\n}\n```\nExtends ArgumentsHost with methods to determine the current handler and class being invoked. Essential for guards and interceptors." }]
+    },
+    "ArgumentsHost": {
+      "contents": [{ "value": "```typescript\ninterface ArgumentsHost {\n  switchToHttp(): HttpArgumentsHost\n  switchToWs(): WsArgumentsHost\n  switchToRpc(): RpcArgumentsHost\n  getType(): string\n}\n```\nProvides methods to retrieve handler arguments for HTTP, WebSocket, or RPC contexts." }]
+    },
+    "Test.createTestingModule": {
+      "contents": [{ "value": "```typescript\nstatic createTestingModule(metadata: ModuleMetadata): TestingModuleBuilder\n```\nCreates a testing module builder. Call `.compile()` to get a `TestingModule` instance for unit and integration tests." }]
+    },
+    "TestingModule": {
+      "contents": [{ "value": "```typescript\nclass TestingModule extends NestApplicationContext {\n  get<T>(typeOrToken: Type<T> | string | symbol): T\n  resolve<T>(typeOrToken: Type<T> | string | symbol): Promise<T>\n  createNestApplication(): INestApplication\n}\n```\nCompiled testing module that provides `get()` for singletons and `resolve()` for request-scoped providers." }]
+    },
+    "DynamicModule": {
+      "contents": [{ "value": "```typescript\ninterface DynamicModule extends ModuleMetadata {\n  module: Type<any>\n  global?: boolean\n}\n```\nInterface returned by static methods like `forRoot()` and `forRootAsync()` for dynamic module registration." }]
+    },
+    "JwtService": {
+      "contents": [{ "value": "```typescript\nclass JwtService {\n  sign(payload: string | object | Buffer, options?: JwtSignOptions): string\n  signAsync(payload: string | object | Buffer, options?: JwtSignOptions): Promise<string>\n  verify<T>(token: string, options?: JwtVerifyOptions): T\n}\n```\nService for signing and verifying JWT tokens. Provided by `JwtModule`." }]
+    },
+    "ThrottlerGuard": {
+      "contents": [{ "value": "```typescript\nclass ThrottlerGuard implements CanActivate\n```\nGuard that limits request rates based on ThrottlerModule configuration. Apply globally or per-route." }]
+    },
+    "Transport": {
+      "contents": [{ "value": "```typescript\nenum Transport { TCP, REDIS, NATS, MQTT, GRPC, RMQ, KAFKA }\n```\nEnum of available microservice transport layers for inter-service communication." }]
+    },
+    "ClientProxy": {
+      "contents": [{ "value": "```typescript\nabstract class ClientProxy {\n  send<TResult, TInput>(pattern: any, data: TInput): Observable<TResult>\n  emit<TResult, TInput>(pattern: any, data: TInput): Observable<TResult>\n}\n```\nProxy class for communicating with microservices. `send()` for request-response, `emit()` for events." }]
+    },
+    "ClientsModule": {
+      "contents": [{ "value": "```typescript\nclass ClientsModule {\n  static register(options: ClientsModuleOptions[]): DynamicModule\n}\n```\nModule for registering microservice client connections. Provides `ClientProxy` instances for inter-service communication." }]
+    },
+    "DocumentBuilder": {
+      "contents": [{ "value": "```typescript\nclass DocumentBuilder {\n  setTitle(title: string): this\n  setDescription(description: string): this\n  setVersion(version: string): this\n  addBearerAuth(): this\n  build(): OpenAPIObject\n}\n```\nBuilder class for creating Swagger/OpenAPI document configuration with a fluent API." }]
+    },
+    "SwaggerModule": {
+      "contents": [{ "value": "```typescript\nclass SwaggerModule {\n  static createDocument(app: INestApplication, config: OpenAPIObject): OpenAPIObject\n  static setup(path: string, app: INestApplication, document: OpenAPIObject): void\n}\n```\nSets up Swagger UI documentation at the specified path. Call `createDocument()` first, then `setup()`." }]
+    },
+    "VersioningType": {
+      "contents": [{ "value": "```typescript\nenum VersioningType { URI, HEADER, MEDIA_TYPE, CUSTOM }\n```\nEnum for API versioning strategies. URI-based is the most common approach." }]
+    },
+    "HttpModule": {
+      "contents": [{ "value": "```typescript\nclass HttpModule {\n  static register(config?: HttpModuleOptions): DynamicModule\n}\n```\nModule that exposes `HttpService` for making external HTTP requests via Axios." }]
+    },
+    "HttpService": {
+      "contents": [{ "value": "```typescript\nclass HttpService {\n  get<T>(url: string, config?: AxiosRequestConfig): Observable<AxiosResponse<T>>\n  post<T>(url: string, data?: any, config?: AxiosRequestConfig): Observable<AxiosResponse<T>>\n}\n```\nService for making HTTP requests using Axios. Returns RxJS Observables." }]
+    },
+    "ParseFilePipe": {
+      "contents": [{ "value": "```typescript\nclass ParseFilePipe implements PipeTransform\n```\nPipe for validating uploaded files. Combine with `MaxFileSizeValidator` and `FileTypeValidator` for comprehensive file validation." }]
+    }
+  }
+}