@enjoys/context-engine 1.3.1 → 1.4.1

package/data/hover/css.json

@@ -63,6 +63,238 @@
     },
     "container-type": {
       "contents": [{ "value": "```css\ncontainer-type: normal | size | inline-size;\n```\n\nEstablishes an element as a containment context for container queries.\n\n- `normal` — no containment (default)\n- `inline-size` — containment on the inline axis only\n- `size` — containment on both axes\n\nUsed with `@container` queries:\n```css\n.card { container-type: inline-size; }\n@container (min-width: 400px) {\n  .card-body { display: flex; }\n}\n```" }]
+    },
+
+    "width": {
+      "contents": [{ "value": "```css\nwidth: <length> | <percentage> | auto | min-content | max-content | fit-content(<length>);\n```\n\nSets the width of an element's content box (or border box with `box-sizing: border-box`).\n\n- `auto` — determined by content and containment\n- `min-content` — shrink to narrowest content\n- `max-content` — expand to widest content\n- `fit-content()` — clamp between min-content and max-content" }]
+    },
+    "height": {
+      "contents": [{ "value": "```css\nheight: <length> | <percentage> | auto | min-content | max-content | fit-content(<length>);\n```\n\nSets the height of the element. Percentages resolve against the containing block's height.\n\n`height: 100vh` fills the full viewport height.\n`height: 100dvh` uses dynamic viewport height (adjusts for mobile browser chrome)." }]
+    },
+    "min-width": {
+      "contents": [{ "value": "```css\nmin-width: <length> | <percentage> | auto | min-content | max-content | fit-content(<length>);\n```\n\nSets the minimum width. The element will never be narrower than this value.\n\nOverrides `width` and `max-width` when they would result in a smaller value." }]
+    },
+    "max-width": {
+      "contents": [{ "value": "```css\nmax-width: <length> | <percentage> | none | min-content | max-content | fit-content(<length>);\n```\n\nSets the maximum width. The element will never be wider than this value.\n\nOverrides `width` but is overridden by `min-width`. Common pattern: `max-width: 1200px; margin: 0 auto;` for centered layouts." }]
+    },
+    "min-height": {
+      "contents": [{ "value": "```css\nmin-height: <length> | <percentage> | auto | min-content | max-content | fit-content(<length>);\n```\n\nSets the minimum height. Useful for ensuring content areas fill available space: `min-height: 100vh;` for full-page layouts." }]
+    },
+    "max-height": {
+      "contents": [{ "value": "```css\nmax-height: <length> | <percentage> | none | min-content | max-content;\n```\n\nSets the maximum height. Commonly used with `overflow: auto` for scrollable regions." }]
+    },
+    "top": {
+      "contents": [{ "value": "```css\ntop: <length> | <percentage> | auto;\n```\n\nSpecifies the vertical position of a positioned element. Behavior depends on `position`:\n- `relative` — offsets from normal position\n- `absolute` — distance from top edge of containing block\n- `fixed` — distance from top of viewport\n- `sticky` — threshold for sticking" }]
+    },
+    "right": {
+      "contents": [{ "value": "```css\nright: <length> | <percentage> | auto;\n```\n\nSpecifies the horizontal position from the right edge of a positioned element's containing block." }]
+    },
+    "bottom": {
+      "contents": [{ "value": "```css\nbottom: <length> | <percentage> | auto;\n```\n\nSpecifies the vertical position from the bottom edge of a positioned element's containing block." }]
+    },
+    "left": {
+      "contents": [{ "value": "```css\nleft: <length> | <percentage> | auto;\n```\n\nSpecifies the horizontal position from the left edge of a positioned element's containing block." }]
+    },
+    "inset": {
+      "contents": [{ "value": "```css\ninset: <length> | <percentage> | auto;\n/* Shorthand for: top right bottom left */\n```\n\nShorthand for `top`, `right`, `bottom`, `left`. Follows the same 1-to-4 value pattern as `margin`.\n\n`inset: 0;` fills the containing block completely (equivalent to `top: 0; right: 0; bottom: 0; left: 0;`)." }]
+    },
+    "flex-wrap": {
+      "contents": [{ "value": "```css\nflex-wrap: nowrap | wrap | wrap-reverse;\n```\n\n- `nowrap` (default) — all items on one line, may overflow\n- `wrap` — items wrap to new lines from top to bottom\n- `wrap-reverse` — items wrap from bottom to top\n\nWhen wrapping, `align-content` controls spacing between lines." }]
+    },
+    "flex-grow": {
+      "contents": [{ "value": "```css\nflex-grow: <number>;\n```\n\nSpecifies how much a flex item grows relative to siblings when positive free space is distributed.\n\n- `0` (default) — don't grow\n- `1` — grow equally\n- `2` — grow twice as much as items with `flex-grow: 1`" }]
+    },
+    "flex-shrink": {
+      "contents": [{ "value": "```css\nflex-shrink: <number>;\n```\n\nSpecifies how much a flex item shrinks relative to siblings when there isn't enough space.\n\n- `1` (default) — shrink equally\n- `0` — don't shrink (useful for fixed-width sidebars)" }]
+    },
+    "flex-basis": {
+      "contents": [{ "value": "```css\nflex-basis: <length> | <percentage> | auto | content;\n```\n\nSets the initial main size of a flex item before free space is distributed.\n\n- `auto` — uses `width`/`height` value\n- `0` — ignores content size, distributes all space via `flex-grow`\n- A specific length — sets an explicit starting size" }]
+    },
+    "align-content": {
+      "contents": [{ "value": "```css\nalign-content: stretch | flex-start | flex-end | center | space-between | space-around | space-evenly;\n```\n\nDistributes space between and around flex/grid lines along the cross axis.\n\nOnly applies when there are multiple lines (flex-wrap: wrap or grid with multiple rows)." }]
+    },
+    "align-self": {
+      "contents": [{ "value": "```css\nalign-self: auto | flex-start | flex-end | center | baseline | stretch;\n```\n\nOverrides `align-items` for a specific flex/grid item. Aligns this item independently on the cross axis." }]
+    },
+    "gap": {
+      "contents": [{ "value": "```css\ngap: <row-gap> <column-gap>?;\n```\n\nShorthand for `row-gap` and `column-gap`. Sets gutters between flex/grid items.\n\n- `gap: 1rem;` — uniform gap\n- `gap: 1rem 2rem;` — row gap | column gap\n\nReplaces the older `grid-gap` property. Works in both Flexbox and Grid." }]
+    },
+    "grid-template-rows": {
+      "contents": [{ "value": "```css\ngrid-template-rows: <track-size>+ | repeat(<count>, <track-size>) | auto;\n```\n\nDefines row sizes in a grid container.\n\nExamples:\n```css\ngrid-template-rows: auto 1fr auto;\ngrid-template-rows: repeat(3, minmax(100px, auto));\ngrid-template-rows: [header] auto [content] 1fr [footer] auto;\n```" }]
+    },
+    "grid-column": {
+      "contents": [{ "value": "```css\ngrid-column: <start-line> / <end-line>;\n```\n\nShorthand for `grid-column-start` / `grid-column-end`. Places a grid item horizontally.\n\nExamples:\n- `grid-column: 1 / 3;` — spans columns 1 and 2\n- `grid-column: 1 / -1;` — spans all columns\n- `grid-column: span 2;` — spans 2 columns from auto-placement" }]
+    },
+    "grid-row": {
+      "contents": [{ "value": "```css\ngrid-row: <start-line> / <end-line>;\n```\n\nShorthand for `grid-row-start` / `grid-row-end`. Places a grid item vertically.\n\nExamples:\n- `grid-row: 1 / 3;` — spans rows 1 and 2\n- `grid-row: span 2;` — spans 2 rows" }]
+    },
+    "grid-auto-flow": {
+      "contents": [{ "value": "```css\ngrid-auto-flow: row | column | dense | row dense | column dense;\n```\n\nControls how auto-placed items flow into the grid.\n\n- `row` (default) — fill rows first\n- `column` — fill columns first\n- `dense` — fill gaps in earlier cells (may reorder visually)" }]
+    },
+    "place-items": {
+      "contents": [{ "value": "```css\nplace-items: <align-items> <justify-items>?;\n```\n\nShorthand for `align-items` and `justify-items`. Centers grid/flex items:\n\n`place-items: center;` centers items both horizontally and vertically." }]
+    },
+    "place-content": {
+      "contents": [{ "value": "```css\nplace-content: <align-content> <justify-content>?;\n```\n\nShorthand for `align-content` and `justify-content`. Distributes space in both axes at once." }]
+    },
+
+    "font-size": {
+      "contents": [{ "value": "```css\nfont-size: <absolute> | <relative> | <length> | <percentage>;\n```\n\nAbsolute keywords: `xx-small`, `x-small`, `small`, `medium`, `large`, `x-large`, `xx-large`.\nRelative: `smaller`, `larger`.\n\nBest practice for responsive text: `font-size: clamp(1rem, 2.5vw, 2rem);`\n\n`em` is relative to parent font-size. `rem` is relative to root (`<html>`) font-size." }]
+    },
+    "font-weight": {
+      "contents": [{ "value": "```css\nfont-weight: normal | bold | bolder | lighter | 100-900;\n```\n\nNumeric scale (100–900 in increments of 100):\n- 100: Thin\n- 300: Light\n- 400: Normal (= `normal`)\n- 500: Medium\n- 700: Bold (= `bold`)\n- 900: Black\n\nVariable fonts support any integer in the 1–1000 range." }]
+    },
+    "font-family": {
+      "contents": [{ "value": "```css\nfont-family: <family-name> | <generic-family>;\n```\n\nGeneric families: `serif`, `sans-serif`, `monospace`, `cursive`, `fantasy`, `system-ui`, `ui-serif`, `ui-sans-serif`, `ui-monospace`.\n\nAlways end with a generic fallback:\n```css\nfont-family: 'Inter', 'Segoe UI', system-ui, sans-serif;\n```\n\nQuote family names containing spaces or special characters." }]
+    },
+    "line-height": {
+      "contents": [{ "value": "```css\nline-height: normal | <number> | <length> | <percentage>;\n```\n\nSets the height of a line box. Unitless values (like `1.5`) are recommended as they scale with font-size.\n\n- `normal` — browser default (~1.2)\n- `1.5` — 1.5× the font-size\n- `24px` — fixed line height\n\nAffects vertical rhythm and readability. WCAG recommends at least 1.5 for body text." }]
+    },
+    "letter-spacing": {
+      "contents": [{ "value": "```css\nletter-spacing: normal | <length>;\n```\n\nSets the space between characters. Negative values tighten text.\n\nCommon usage:\n- Headings: `letter-spacing: -0.025em;` (tighter)\n- Uppercase text: `letter-spacing: 0.05em;` (wider)\n- Body text: `letter-spacing: normal;`" }]
+    },
+    "text-align": {
+      "contents": [{ "value": "```css\ntext-align: left | right | center | justify | start | end;\n```\n\nAligns inline content within a block element.\n\n- `start`/`end` — logical values that respect writing direction (RTL-safe)\n- `justify` — stretches lines to fill width; last line is left-aligned" }]
+    },
+    "text-decoration": {
+      "contents": [{ "value": "```css\ntext-decoration: <line> <style>? <color>? <thickness>?;\n```\n\nShorthand for `text-decoration-line`, `text-decoration-style`, `text-decoration-color`, `text-decoration-thickness`.\n\nLines: `none`, `underline`, `overline`, `line-through`.\nStyles: `solid`, `double`, `dotted`, `dashed`, `wavy`.\n\n`text-underline-offset` adjusts position of underlines." }]
+    },
+    "text-transform": {
+      "contents": [{ "value": "```css\ntext-transform: none | capitalize | uppercase | lowercase | full-width;\n```\n\n- `capitalize` — first letter of each word uppercased\n- `uppercase` — all characters uppercased\n- `lowercase` — all characters lowercased\n\nNote: Doesn't change the actual content, only the visual presentation." }]
+    },
+    "text-overflow": {
+      "contents": [{ "value": "```css\ntext-overflow: clip | ellipsis;\n```\n\nSpecifies how overflowed text that is not displayed is signaled.\n\nRequires `overflow: hidden` and `white-space: nowrap` to take effect.\n\nClassic truncation pattern:\n```css\noverflow: hidden;\nwhite-space: nowrap;\ntext-overflow: ellipsis;\n```" }]
+    },
+    "white-space": {
+      "contents": [{ "value": "```css\nwhite-space: normal | nowrap | pre | pre-wrap | pre-line | break-spaces;\n```\n\n- `normal` — collapse whitespace, wrap at available width\n- `nowrap` — collapse whitespace, no wrapping\n- `pre` — preserve whitespace and newlines, no wrapping\n- `pre-wrap` — preserve whitespace, wrap at available width\n- `pre-line` — collapse whitespace, preserve newlines, wrap" }]
+    },
+    "word-break": {
+      "contents": [{ "value": "```css\nword-break: normal | break-all | keep-all | break-word;\n```\n\n- `normal` — break at allowed break points\n- `break-all` — break anywhere (for CJK text or long strings)\n- `keep-all` — don't break CJK characters\n- `break-word` — break at word boundaries, then anywhere if needed (deprecated, use `overflow-wrap: anywhere` instead)" }]
+    },
+    "overflow-wrap": {
+      "contents": [{ "value": "```css\noverflow-wrap: normal | break-word | anywhere;\n```\n\nAllows unbreakable strings to be broken to prevent overflow.\n\n- `break-word` — break long words at arbitrary points if needed\n- `anywhere` — like `break-word` but also considers soft wrap opportunities for min-content sizing" }]
+    },
+
+    "color": {
+      "contents": [{ "value": "```css\ncolor: <color>;\n```\n\nSets the foreground color for text content and text decorations.\n\nColor formats:\n- Named: `red`, `rebeccapurple`\n- Hex: `#ff0000`, `#f00`, `#ff000080`\n- RGB: `rgb(255 0 0)`, `rgb(255 0 0 / 50%)`\n- HSL: `hsl(0 100% 50%)`, `hsl(0 100% 50% / 50%)`\n- OKLCH: `oklch(70% 0.25 30)`\n- Keywords: `currentColor`, `transparent`, `inherit`" }]
+    },
+    "background-color": {
+      "contents": [{ "value": "```css\nbackground-color: <color>;\n```\n\nSets the background color. Painted behind `background-image`.\n\nSupports all color formats including alpha transparency:\n`background-color: rgb(0 0 0 / 50%);`" }]
+    },
+    "background-image": {
+      "contents": [{ "value": "```css\nbackground-image: none | <image>+;\n```\n\nSets one or more background images. Supports gradients as images.\n\nExamples:\n```css\nbackground-image: url('bg.jpg');\nbackground-image: linear-gradient(to right, #000, #fff);\nbackground-image: radial-gradient(circle, #000, transparent);\nbackground-image: conic-gradient(from 45deg, red, blue);\n```\n\nMultiple backgrounds are layered: first declared is on top." }]
+    },
+    "background-size": {
+      "contents": [{ "value": "```css\nbackground-size: auto | <length> | <percentage> | cover | contain;\n```\n\n- `cover` — scales image to fill element (may crop)\n- `contain` — scales image to fit entirely (may leave gaps)\n- `auto` — natural image dimensions\n\nTwo values: `background-size: width height;`" }]
+    },
+    "background-position": {
+      "contents": [{ "value": "```css\nbackground-position: <position>;\n```\n\nSets the initial position of a background image.\n\nKeywords: `top`, `right`, `bottom`, `left`, `center`.\nValues: `background-position: 50% 50%;` (centered)\nMulti-value: `background-position: right 10px bottom 20px;`" }]
+    },
+    "linear-gradient()": {
+      "contents": [{ "value": "```css\nlinear-gradient(<angle> | to <side>, <color-stop>, ...)\n```\n\nCreates a linear color transition.\n\nAngles: `0deg` (up), `90deg` (right), `180deg` (down), `270deg` (left).\nKeywords: `to right`, `to bottom right`, etc.\n\nExamples:\n```css\nlinear-gradient(135deg, #667eea 0%, #764ba2 100%);\nlinear-gradient(to right, red, transparent);\nlinear-gradient(to bottom, #000 0%, #000 50%, #fff 50%, #fff 100%);\n```" }]
+    },
+    "radial-gradient()": {
+      "contents": [{ "value": "```css\nradial-gradient(<shape> <size> at <position>, <color-stop>, ...)\n```\n\nCreates a radial color transition from a center point.\n\nShapes: `circle`, `ellipse` (default).\nSizes: `closest-side`, `farthest-side`, `closest-corner`, `farthest-corner`.\n\nExample: `radial-gradient(circle at top left, #667eea, transparent);`" }]
+    },
+
+    "border-width": {
+      "contents": [{ "value": "```css\nborder-width: <length>{1,4};\n```\n\nSets the width of all four borders. Uses the same 1-to-4 value shorthand as `margin`.\n\nKeywords: `thin` (~1px), `medium` (~3px), `thick` (~5px).\n\nIndividual sides: `border-top-width`, `border-right-width`, etc." }]
+    },
+    "border-style": {
+      "contents": [{ "value": "```css\nborder-style: none | solid | dashed | dotted | double | groove | ridge | inset | outset | hidden;\n```\n\nSets the line style of all four borders. `none` and `hidden` both render no border, but `hidden` wins in border-collapsing table cells." }]
+    },
+    "border-color": {
+      "contents": [{ "value": "```css\nborder-color: <color>{1,4};\n```\n\nSets the color of all four borders. Uses 1-to-4 value shorthand.\n\nDefaults to `currentColor` if not specified." }]
+    },
+    "outline": {
+      "contents": [{ "value": "```css\noutline: <width> <style> <color>;\n```\n\nDraws a line outside the element's border. Does NOT affect layout (no space taken).\n\nUnlike `border`, `outline` doesn't have corners — use `outline-offset` to push it away from the element.\n\n`outline: 2px solid blue;` is the default focus indicator in many browsers.\n`outline: none;` removes it (only do this with a visible alternative)." }]
+    },
+    "box-shadow": {
+      "contents": [{ "value": "```css\nbox-shadow: <inset>? <offset-x> <offset-y> <blur> <spread>? <color>;\n```\n\nAdds shadow effects. Supports multiple shadows separated by commas.\n\nExamples:\n```css\nbox-shadow: 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24);\nbox-shadow: inset 0 2px 4px rgba(0,0,0,0.1);\nbox-shadow: 0 0 0 3px rgba(66,153,225,0.5); /* ring effect */\n```" }]
+    },
+    "filter": {
+      "contents": [{ "value": "```css\nfilter: <filter-function>+;\n```\n\nFunctions: `blur()`, `brightness()`, `contrast()`, `grayscale()`, `hue-rotate()`, `invert()`, `opacity()`, `saturate()`, `sepia()`, `drop-shadow()`.\n\nExamples:\n```css\nfilter: blur(4px);\nfilter: grayscale(100%) brightness(0.8);\nfilter: drop-shadow(2px 4px 6px rgba(0,0,0,0.3));\n```\n\n`drop-shadow()` follows the alpha shape (unlike `box-shadow`)." }]
+    },
+    "backdrop-filter": {
+      "contents": [{ "value": "```css\nbackdrop-filter: <filter-function>+;\n```\n\nApplies filter effects to the area behind an element. Uses the same functions as `filter`.\n\nGlass morphism pattern:\n```css\nbackdrop-filter: blur(10px);\nbackground-color: rgba(255, 255, 255, 0.3);\n```\n\nRequires a transparent/semi-transparent background to be visible." }]
+    },
+    "mix-blend-mode": {
+      "contents": [{ "value": "```css\nmix-blend-mode: normal | multiply | screen | overlay | darken | lighten | color-dodge | color-burn | hard-light | soft-light | difference | exclusion | hue | saturation | color | luminosity;\n```\n\nDefines how an element's content blends with the content behind it.\n\n`isolation: isolate;` on a parent creates a new stacking context, preventing blend from affecting ancestors." }]
+    },
+    "object-fit": {
+      "contents": [{ "value": "```css\nobject-fit: fill | contain | cover | none | scale-down;\n```\n\nSets how `<img>`, `<video>`, or other replaced elements resize to fit their container.\n\n- `cover` — fill container, maintain aspect ratio (may crop)\n- `contain` — fit entirely, maintain aspect ratio (may letterbox)\n- `fill` — stretch to fill (may distort)\n- `none` — natural size\n- `scale-down` — `none` or `contain`, whichever is smaller\n\nUsed with `object-position` to control placement." }]
+    },
+    "object-position": {
+      "contents": [{ "value": "```css\nobject-position: <position>;\n```\n\nSets the alignment of replaced content within its box. Uses the same syntax as `background-position`.\n\nDefault: `50% 50%` (centered).\nExample: `object-position: top center;`" }]
+    },
+    "aspect-ratio": {
+      "contents": [{ "value": "```css\naspect-ratio: auto | <width> / <height>;\n```\n\nSets a preferred aspect ratio for the element's box.\n\nExamples:\n- `aspect-ratio: 16 / 9;` — widescreen video\n- `aspect-ratio: 1;` — square\n- `aspect-ratio: 4 / 3;` — classic photo\n\nWorks with `width: 100%;` to create responsive containers that maintain their ratio." }]
+    },
+    "overflow-x": {
+      "contents": [{ "value": "```css\noverflow-x: visible | hidden | clip | scroll | auto;\n```\n\nControls horizontal overflow behavior.\n`overflow-x: auto;` adds a scrollbar only when content overflows horizontally." }]
+    },
+    "overflow-y": {
+      "contents": [{ "value": "```css\noverflow-y: visible | hidden | clip | scroll | auto;\n```\n\nControls vertical overflow behavior.\n`overflow-y: auto;` adds a scrollbar only when content overflows vertically." }]
+    },
+    "visibility": {
+      "contents": [{ "value": "```css\nvisibility: visible | hidden | collapse;\n```\n\n- `visible` — element is visible\n- `hidden` — element is invisible but still occupies space (unlike `display: none`)\n- `collapse` — for table elements, removes row/column; behaves like `hidden` for others\n\nHidden elements still receive events and can be tab-focused." }]
+    },
+    "pointer-events": {
+      "contents": [{ "value": "```css\npointer-events: auto | none;\n```\n\n- `auto` — element responds to pointer events normally\n- `none` — element is \"transparent\" to pointer events; clicks pass through to elements below\n\nUseful for overlays, disabled states, and decorative elements." }]
+    },
+    "user-select": {
+      "contents": [{ "value": "```css\nuser-select: auto | text | none | all | contain;\n```\n\nControls whether text can be selected.\n\n- `none` — prevents text selection (useful for UI elements)\n- `all` — entire element selected on click (useful for code blocks)\n- `text` — text can be selected normally" }]
+    },
+    "resize": {
+      "contents": [{ "value": "```css\nresize: none | both | horizontal | vertical | block | inline;\n```\n\nSets whether an element is resizable by the user.\n\nRequires `overflow` other than `visible`. `<textarea>` is resizable by default." }]
+    },
+    "scroll-behavior": {
+      "contents": [{ "value": "```css\nscroll-behavior: auto | smooth;\n```\n\nSets whether scrolling is instant or animated.\n\n`html { scroll-behavior: smooth; }` enables smooth scrolling for all anchor links and `scrollTo()` calls." }]
+    },
+    "scroll-snap-type": {
+      "contents": [{ "value": "```css\nscroll-snap-type: none | <axis> <strictness>?;\n```\n\nAxis: `x`, `y`, `block`, `inline`, `both`.\nStrictness: `mandatory`, `proximity`.\n\nCarousel pattern:\n```css\n.container { scroll-snap-type: x mandatory; overflow-x: auto; }\n.item { scroll-snap-align: start; }\n```" }]
+    },
+    "will-change": {
+      "contents": [{ "value": "```css\nwill-change: auto | <property>+;\n```\n\nHints to the browser about upcoming changes for optimization.\n\nExamples:\n- `will-change: transform;` — optimizes for transform animations\n- `will-change: opacity;` — optimizes for opacity changes\n\nUse sparingly — add before animation, remove after. Excessive use wastes GPU memory." }]
+    },
+    "contain": {
+      "contents": [{ "value": "```css\ncontain: none | strict | content | size | layout | style | paint;\n```\n\nIndicates containment restrictions to the browser for performance optimization.\n\n- `layout` — element's layout is independent of the rest of the page\n- `paint` — descendants are not rendered outside the element's bounds\n- `size` — element's size is not affected by its descendants\n- `content` — shorthand for `layout paint style`\n- `strict` — shorthand for `layout paint size style`" }]
+    },
+    "accent-color": {
+      "contents": [{ "value": "```css\naccent-color: auto | <color>;\n```\n\nSets the accent color for form controls: checkboxes, radio buttons, range sliders, and progress bars.\n\n`accent-color: auto;` uses the browser/OS default.\n\nSimplifies form theming without custom styling." }]
+    },
+    "color-scheme": {
+      "contents": [{ "value": "```css\ncolor-scheme: normal | light | dark | light dark;\n```\n\nIndicates which color schemes the element supports.\n\n`:root { color-scheme: light dark; }` tells the browser both are supported, enabling native dark mode for form controls, scrollbars, and other UA-rendered elements." }]
+    },
+    "::placeholder": {
+      "contents": [{ "value": "```css\n::placeholder {\n  color: <color>;\n  opacity: <number>;\n  font-style: <style>;\n}\n```\n\nStyles the placeholder text of `<input>` and `<textarea>` elements.\n\nNote: Default opacity varies by browser (Firefox uses 0.54). Set `opacity: 1;` for consistent rendering." }]
+    },
+    "@container": {
+      "contents": [{ "value": "```css\n@container <name>? (<condition>) { ... }\n```\n\nApplies styles based on the size of a containing element (not the viewport).\n\nConditions: `min-width`, `max-width`, `min-height`, `max-height`, `width`, `inline-size`, `block-size`.\n\nRequires `container-type` on ancestor:\n```css\n.parent { container-type: inline-size; container-name: card; }\n@container card (min-width: 400px) { .child { flex-direction: row; } }\n```" }]
+    },
+    "@layer": {
+      "contents": [{ "value": "```css\n@layer <name>;\n@layer <name> { ... }\n@layer <name1>, <name2>, <name3>;\n```\n\nDeclares cascade layers to control specificity ordering.\n\n- Layers declared earlier have **lower** priority\n- Unlayered styles have **higher** priority than layered styles\n- Layers can be nested: `@layer framework.components { }`\n\nUseful for managing third-party CSS specificity conflicts." }]
+    },
+    "@supports": {
+      "contents": [{ "value": "```css\n@supports (<condition>) { ... }\n@supports not (<condition>) { ... }\n@supports (<condition>) and (<condition>) { ... }\n```\n\nFeature queries — conditionally applies styles based on browser support.\n\nExamples:\n```css\n@supports (display: grid) { .layout { display: grid; } }\n@supports selector(:has()) { .parent:has(.child) { color: red; } }\n@supports (backdrop-filter: blur(10px)) { .glass { backdrop-filter: blur(10px); } }\n```" }]
+    },
+    "@import": {
+      "contents": [{ "value": "```css\n@import url(<path>) <media>? <layer>?;\n```\n\nImports an external stylesheet. Must appear before all rules except `@charset` and `@layer`.\n\nExamples:\n```css\n@import url('reset.css');\n@import url('print.css') print;\n@import url('lib.css') layer(lib);\n@import url('dark.css') (prefers-color-scheme: dark);\n```\n\nNote: Multiple `@import` rules create sequential blocking requests. Consider bundling instead." }]
+    },
+    "min()": {
+      "contents": [{ "value": "```css\nmin(<value>, <value>, ...)\n```\n\nReturns the smallest value from a comma-separated list.\n\nExample: `width: min(100%, 600px);` — never exceeds 600px but also never exceeds parent width.\n\nEquivalent to `max-width`-like behavior without a separate property." }]
+    },
+    "max()": {
+      "contents": [{ "value": "```css\nmax(<value>, <value>, ...)\n```\n\nReturns the largest value from a comma-separated list.\n\nExample: `width: max(300px, 50%);` — at least 300px but grows with parent.\n\nEquivalent to `min-width`-like behavior without a separate property." }]
+    },
+    ":has()": {
+      "contents": [{ "value": "```css\n:has(<selector>)\n```\n\nThe \"parent selector\" — matches an element if any of its descendants match the argument selector.\n\nExamples:\n```css\n.card:has(img) { padding: 0; }\n.form:has(:invalid) { border-color: red; }\nh2:has(+ p) { margin-bottom: 0; } /* h2 followed by p */\n```\n\nHighly powerful but use carefully for performance — browser evaluates from the subject outward." }]
+    },
+    ":is()": {
+      "contents": [{ "value": "```css\n:is(<selector-list>)\n```\n\nMatches any element that can be matched by one of the selectors in the list. Simplifies complex selectors.\n\n```css\n:is(h1, h2, h3) { color: blue; }\n:is(.card, .panel) :is(h2, h3) { margin: 0; }\n```\n\nSpecificity: takes the **most specific** selector in the list. Use `:where()` for zero-specificity version." }]
+    },
+    ":where()": {
+      "contents": [{ "value": "```css\n:where(<selector-list>)\n```\n\nSame as `:is()` but with **zero specificity**. Ideal for default stylesheets that should be easily overridable.\n\n```css\n:where(.dialog, .modal) { margin: auto; }\n```" }]
     }
   }
 }

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." }]
+    }
+  }
+}