@alloy-js/python 0.5.0-dev.2 → 0.6.0-dev.0

package/temp/api.json

@@ -1,7 +1,7 @@
 {
   "metadata": {
     "toolPackage": "@microsoft/api-extractor",
-    "toolVersion": "7.52.9",
+    "toolVersion": "7.58.8",
     "schemaVersion": 1011,
     "oldestForwardsCompatibleVersion": 1001,
     "tsdocConfig": {
@@ -114,6 +114,22 @@
           "tagName": "@virtual",
           "syntaxKind": "modifier"
         },
+        {
+          "tagName": "@jsx",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@jsxRuntime",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@jsxFrag",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@jsxImportSource",
+          "syntaxKind": "block"
+        },
         {
           "tagName": "@betaDocumentation",
           "syntaxKind": "modifier"
@@ -227,7 +243,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!AddImportOptions#type:member",
-              "docComment": "/**\n * If true, this import is only used in type annotation contexts.\n * Such imports will be guarded with `if TYPE_CHECKING:`.\n */\n",
+              "docComment": "/**\n * If true, this import is only used in type annotation contexts. Such imports will be guarded with `if TYPE_CHECKING:`.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -257,7 +273,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!Atom:function(1)",
-          "docComment": "/**\n * A component that renders a JavaScript value as a Python atom (atomic value).\n * It handles various types of atomic values including numbers, booleans, strings,\n * functions, arrays, and objects, converting them to Python-like syntax.\n *\n * @example\n * ```tsx\n * <Atom jsValue={42} /> // renders \"42\"\n * <Atom jsValue={true} /> // renders \"True\"\n * <Atom jsValue=\"Hello\" /> // renders '\"Hello\"'\n * <Atom jsValue={[1, 2, 3]} /> // renders \"[1, 2, 3]\"\n * <Atom jsValue={{ key: \"value\" }} />\n * ```\n *\n */\n",
+          "docComment": "/**\n * A component that renders a JavaScript value as a Python atom (atomic value). It handles various types of atomic values including numbers, booleans, strings, functions, arrays, and objects, converting them to Python-like syntax.\n *\n * @example\n * ```tsx\n * <Atom jsValue={42} /> // renders \"42\"\n * <Atom jsValue={true} /> // renders \"True\"\n * <Atom jsValue=\"Hello\" /> // renders '\"Hello\"'\n * <Atom jsValue={[1, 2, 3]} /> // renders \"[1, 2, 3]\"\n * <Atom jsValue={{ key: \"value\" }} />\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -375,7 +391,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!AttributeDoc:function(1)",
-          "docComment": "/**\n * A component that creates documentation for a single attribute.\n * This can be used for both inline and block attribute documentation.\n */\n",
+          "docComment": "/**\n * A component that creates documentation for a single attribute. This can be used for both inline and block attribute documentation.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -622,7 +638,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!BaseDeclarationProps#name:member",
-              "docComment": "/**\n * The base name of this declaration. May change depending on naming policy\n * and any conflicts.\n */\n",
+              "docComment": "/**\n * The base name of this declaration. May change depending on naming policy and any conflicts.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -698,7 +714,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!CallSignature:function(1)",
-          "docComment": "/**\n * A Python call signature, e.g. the part after the `def` keyword and the name in a\n * function expression.\n *\n * @remarks\n *\n *\n *\n * Any parameters or type parameters declared in this signature will be placed\n * in the current scope. This component does not make a scope to hold its\n * parameters.\n *\n * @example\n * ```tsx\n * <CallSignature\n *   parameters={[{ name: \"a\", type: \"int\" }, { name: \"b\", type: \"str\" }]}\n *   returnType=\"int\"\n * />\n * ```\n *\n * renders to\n * ```py\n * (a: int, b: str) -> int\n * ```\n *\n */\n",
+          "docComment": "/**\n * A Python call signature, e.g. the part after the `def` keyword and the name in a function expression.\n *\n * @remarks\n *\n * Any parameters or type parameters declared in this signature will be placed in the current scope. This component does not make a scope to hold its parameters.\n *\n * @example\n * ```tsx\n * <CallSignature\n *   parameters={[{ name: \"a\", type: \"int\" }, { name: \"b\", type: \"str\" }]}\n *   returnType=\"int\"\n * />\n * ```\n *\n * renders to\n * ```py\n * (a: int, b: str) -> int\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -745,7 +761,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!CallSignatureParameters:function(1)",
-          "docComment": "/**\n * A call signature parameters declaration, which can be used to define the\n * parameters of a function or other callables.\n *\n * @example\n * ```tsx\n * <py.CallSignatureParameters parameters={[ \"a\", \"b\" ]} />\n * ```\n *\n * This will generate:\n * ```python\n * a, b\n * ```\n *\n */\n",
+          "docComment": "/**\n * A call signature parameters declaration, which can be used to define the parameters of a function or other callables.\n *\n * @example\n * ```tsx\n * <py.CallSignatureParameters parameters={[ \"a\", \"b\" ]} />\n * ```\n *\n * This will generate:\n * ```python\n * a, b\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -978,7 +994,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!CallSignatureProps#parameters:member",
-              "docComment": "/**\n * The parameters to the call signature. Can be an array of strings (for simple\n * parameter names), {@link ParameterDescriptor}s, or special markers (\"*\" for\n * keyword-only, \"/\" for positional-only).\n */\n",
+              "docComment": "/**\n * The parameters to the call signature. Can be an array of strings (for simple parameter names), {@link ParameterDescriptor}s, or special markers (\"*\" for keyword-only, \"/\" for positional-only).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1051,7 +1067,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!CallSignatureProps#typeParameters:member",
-              "docComment": "/**\n * The type parameters of the call signature, e.g. for a generic function.\n * This is only supported in Python 3.12+.\n */\n",
+              "docComment": "/**\n * The type parameters of the call signature, e.g. for a generic function. This is only supported in Python 3.12+.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1081,7 +1097,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!ClassDeclaration:function(1)",
-          "docComment": "/**\n * Create a Python class declaration.\n *\n * @remarks\n *\n *\n *\n * Any child declarations (methods, fields, nested classes) will be placed\n * in the class scope. This component creates a class scope to hold its\n * members.\n *\n * @example\n * ```tsx\n * <ClassDeclaration name=\"MyClass\" bases={[\"BaseClass\"]}>\n *   <VariableDeclaration name=\"a\" type=\"int\" />\n *   <VariableDeclaration name=\"b\" type=\"str\" />\n *   <py.FunctionDeclaration name=\"my_method\" parameters={[{ name: \"a\", type: \"int\" }, { name: \"b\", type: \"str\" }]} returnType=\"int\">\n *     return a + b\n *   </py.FunctionDeclaration>\n * </ClassDeclaration>\n * ```\n *\n * renders to\n * ```py\n * class MyClass(BaseClass):\n *   a: int = None\n *   b: str = None\n *   def my_method(self, a: int, b: str) -> int:\n *     return a + b\n * ```\n *\n */\n",
+          "docComment": "/**\n * Create a Python class declaration.\n *\n * @remarks\n *\n * Any child declarations (methods, fields, nested classes) will be placed in the class scope. This component creates a class scope to hold its members.\n *\n * @example\n * ```tsx\n * <ClassDeclaration name=\"MyClass\" bases={[\"BaseClass\"]}>\n *   <VariableDeclaration name=\"a\" type=\"int\" />\n *   <VariableDeclaration name=\"b\" type=\"str\" />\n *   <py.FunctionDeclaration name=\"my_method\" parameters={[{ name: \"a\", type: \"int\" }, { name: \"b\", type: \"str\" }]} returnType=\"int\">\n *     return a + b\n *   </py.FunctionDeclaration>\n * </ClassDeclaration>\n * ```\n *\n * renders to\n * ```py\n * class MyClass(BaseClass):\n *   a: int = None\n *   b: str = None\n *   def my_method(self, a: int, b: str) -> int:\n *     return a + b\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -1184,7 +1200,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!ClassDeclarationProps#decorators:member",
-              "docComment": "/**\n * Decorators rendered above the `class` keyword, in source order —\n * `decorators[0]` is topmost. By Python's bottom-up application order, the\n * topmost entry is the outermost decorator (applied last).\n *\n * Each entry should produce a complete decorator line (typically starting\n * with `@`). Falsy entries are skipped, so conditional decorators can be\n * provided inline when needed.\n *\n * Wrappers like `DataclassDeclaration` build their intrinsic decorator\n * (e.g. `@dataclass(...)`) and append it to this list at the position that\n * keeps `@dataclass` closest to the class — i.e. user `decorators` end up\n * **above** the intrinsic one, matching how Pydantic's `@field_validator`\n * sits above `@classmethod` on methods.\n *\n * Do **not** pass a wrapper's intrinsic decorator here. For example, when\n * using `DataclassDeclaration`, do not include `@dataclass(...)` in\n * `decorators` — the component renders it for you, and stacking it twice\n * would produce invalid Python.\n */\n",
+              "docComment": "/**\n * Decorators rendered above the `class` keyword, in source order — `decorators[0]` is topmost. By Python's bottom-up application order, the topmost entry is the outermost decorator (applied last).\n *\n * Each entry should produce a complete decorator line (typically starting with `@`). Falsy entries are skipped, so conditional decorators can be provided inline when needed.\n *\n * Wrappers like `DataclassDeclaration` build their intrinsic decorator (e.g. `@dataclass(...)`) and append it to this list at the position that keeps `@dataclass` closest to the class — i.e. user `decorators` end up **above** the intrinsic one, matching how Pydantic's `@field_validator` sits above `@classmethod` on methods.\n *\n * Do **not** pass a wrapper's intrinsic decorator here. For example, when using `DataclassDeclaration`, do not include `@dataclass(...)` in `decorators` — the component renders it for you, and stacking it twice would produce invalid Python.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1552,7 +1568,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!ClassEnumDeclaration:function(1)",
-          "docComment": "/**\n * Create a Python enum using the class-based syntax.\n *\n * This generates enums using the `class Name(Enum):` syntax with member definitions\n * inside the class body. Supports various member value styles including auto-generated\n * values, explicit values, and custom base types.\n *\n * @example\n * ```tsx\n * <ClassEnumDeclaration\n *   name=\"Direction\"\n *   members={[\n *     { name: \"NORTH\" },\n *     { name: \"SOUTH\" },\n *     { name: \"EAST\" },\n *     { name: \"WEST\" }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * class Direction(Enum):\n *     NORTH = \"NORTH\"\n *     SOUTH = \"SOUTH\"\n *     EAST = \"EAST\"\n *     WEST = \"WEST\"\n * ```\n *\n * @example\n *\n *\n * With explicit values:\n * ```tsx\n * <ClassEnumDeclaration\n *   name=\"Status\"\n *   members={[\n *     { name: \"PENDING\", value: 1 },\n *     { name: \"ACTIVE\", value: 2 },\n *     { name: \"INACTIVE\", value: 3 }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * class Status(Enum):\n *     PENDING = 1\n *     ACTIVE = 2\n *     INACTIVE = 3\n * ```\n *\n * @example\n *\n *\n * With auto() values:\n * ```tsx\n * <ClassEnumDeclaration\n *   name=\"Color\"\n *   style=\"auto\"\n *   members={[\n *     { name: \"RED\" },\n *     { name: \"GREEN\" },\n *     { name: \"BLUE\" }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * class Color(Enum):\n *     RED = auto()\n *     GREEN = auto()\n *     BLUE = auto()\n * ```\n *\n */\n",
+          "docComment": "/**\n * Create a Python enum using the class-based syntax.\n *\n * This generates enums using the `class Name(Enum):` syntax with member definitions inside the class body. Supports various member value styles including auto-generated values, explicit values, and custom base types.\n *\n * @example\n * ```tsx\n * <ClassEnumDeclaration\n *   name=\"Direction\"\n *   members={[\n *     { name: \"NORTH\" },\n *     { name: \"SOUTH\" },\n *     { name: \"EAST\" },\n *     { name: \"WEST\" }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * class Direction(Enum):\n *     NORTH = \"NORTH\"\n *     SOUTH = \"SOUTH\"\n *     EAST = \"EAST\"\n *     WEST = \"WEST\"\n * ```\n *\n * @example\n *\n * With explicit values:\n * ```tsx\n * <ClassEnumDeclaration\n *   name=\"Status\"\n *   members={[\n *     { name: \"PENDING\", value: 1 },\n *     { name: \"ACTIVE\", value: 2 },\n *     { name: \"INACTIVE\", value: 3 }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * class Status(Enum):\n *     PENDING = 1\n *     ACTIVE = 2\n *     INACTIVE = 3\n * ```\n *\n * @example\n *\n * With auto() values:\n * ```tsx\n * <ClassEnumDeclaration\n *   name=\"Color\"\n *   style=\"auto\"\n *   members={[\n *     { name: \"RED\" },\n *     { name: \"GREEN\" },\n *     { name: \"BLUE\" }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * class Color(Enum):\n *     RED = auto()\n *     GREEN = auto()\n *     BLUE = auto()\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -1650,7 +1666,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!ClassEnumProps#decorators:member",
-              "docComment": "/**\n * Decorators rendered above `class <Name>(<BaseType>):`. See\n * {@link ClassDeclarationProps.decorators} for the source-order and falsy\n * skip semantics.\n *\n * Not available on functional-enum syntax (`Name = Enum(...)`), which is a\n * variable assignment rather than a class definition.\n */\n",
+              "docComment": "/**\n * Decorators rendered above `class <Name>(<BaseType>):`. See {@link ClassDeclarationProps.decorators} for the source-order and falsy skip semantics.\n *\n * Not available on functional-enum syntax (`Name = Enum(...)`), which is a variable assignment rather than a class definition.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1690,7 +1706,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!ClassInstantiation:function(1)",
-          "docComment": "/**\n * Used to create new instances of classes in Python.\n *\n * @remarks\n *\n *\n *\n * It is similar to FunctionCallExpression but specifically for class instantiation.\n * Args should be a list arguments that can be either simple js values or py.Atoms, which will render as positional arguments,\n * or py.VariableDeclarations, which will render as named arguments in the call statement. This component will\n * not check for the correctness of the python grammar and will just work with any children you provide.\n * It is up to you to ensure that the arguments you provide are valid in the context of a class instantiation.\n *\n * @example\n * ```tsx\n * <ClassInstantiation target=\"MyClass\" args={[\"arg1\", \"arg2\"]} />\n * ```\n *\n * This will generate:\n * ```python\n * MyClass(arg1, arg2)\n * ```\n *\n */\n",
+          "docComment": "/**\n * Used to create new instances of classes in Python.\n *\n * @remarks\n *\n * It is similar to FunctionCallExpression but specifically for class instantiation. Args should be a list arguments that can be either simple js values or py.Atoms, which will render as positional arguments, or py.VariableDeclarations, which will render as named arguments in the call statement. This component will not check for the correctness of the python grammar and will just work with any children you provide. It is up to you to ensure that the arguments you provide are valid in the context of a class instantiation.\n *\n * @example\n * ```tsx\n * <ClassInstantiation target=\"MyClass\" args={[\"arg1\", \"arg2\"]} />\n * ```\n *\n * This will generate:\n * ```python\n * MyClass(arg1, arg2)\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -1823,7 +1839,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/python!ClassMethodDeclarationProps:interface",
-          "docComment": "/**\n * A Python class method declaration component.\n *\n * @remarks\n *\n *\n * Use **`decorators`** for decorators that must appear above `@classmethod`\n * (for example Pydantic `@field_validator`).\n *\n * @example\n * ```tsx\n * <py.ClassMethodDeclaration name=\"create\" parameters={[{ name: \"value\", type: \"str\" }]}>\n *   return cls(value)\n * </py.ClassMethodDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @classmethod\n * def create(cls, value: str) -> None:\n *     return cls(value)\n * ```\n *\n */\n",
+          "docComment": "/**\n * A Python class method declaration component.\n *\n * @remarks\n *\n * Use **`decorators`** for decorators that must appear above `@classmethod` (for example Pydantic `@field_validator`).\n *\n * @example\n * ```tsx\n * <py.ClassMethodDeclaration name=\"create\" parameters={[{ name: \"value\", type: \"str\" }]}>\n *   return cls(value)\n * </py.ClassMethodDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @classmethod\n * def create(cls, value: str) -> None:\n *     return cls(value)\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -1882,7 +1898,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/python!CommonFunctionProps:interface",
-          "docComment": "/**\n * Shared base interface for function-like components.\n *\n * @remarks\n *\n *\n * This interface is consumed by public components like `FunctionDeclaration`,\n * `MethodDeclaration`, and property method helpers. It combines declaration\n * metadata with call signature shape.\n */\n",
+          "docComment": "/**\n * Shared base interface for function-like components.\n *\n * @remarks\n *\n * This interface is consumed by public components like `FunctionDeclaration`, `MethodDeclaration`, and property method helpers. It combines declaration metadata with call signature shape.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -1942,7 +1958,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!CommonFunctionProps#decorators:member",
-              "docComment": "/**\n * Decorators rendered above `def`, in source order — `decorators[0]` is\n * topmost. By Python's bottom-up application order, the topmost entry is\n * the **outermost** decorator (applied last) and wraps the result of every\n * decorator below it.\n *\n * Each entry should produce a complete decorator line (typically starting\n * with `@`). Falsy entries (other than `0`) are skipped, so conditional\n * decorators can be provided inline when needed.\n *\n * When used through wrappers that emit an intrinsic decorator\n * (`ClassMethodDeclaration` → `@classmethod`,\n * `StaticMethodDeclaration` → `@staticmethod`,\n * `PropertyDeclaration` → `@property`), these decorators are rendered\n * **above** the intrinsic line — the correct position for Pydantic's\n * `@field_validator` / `@model_validator` and other wrappers that must\n * see the underlying function, not a descriptor.\n *\n * When used on plain `MethodDeclaration` / `FunctionDeclaration`, these\n * decorators are rendered above `@abstractmethod` (if `abstract` is set)\n * and above `def`.\n *\n * Do **not** pass intrinsic decorators here — i.e. `@classmethod`,\n * `@staticmethod`, `@property`, or `@abstractmethod`. Those are emitted by\n * the matching component (`ClassMethodDeclaration`, `StaticMethodDeclaration`,\n * `PropertyDeclaration`, or the `abstract` flag) and would otherwise be\n * stacked twice in the output, producing invalid Python.\n */\n",
+              "docComment": "/**\n * Decorators rendered above `def`, in source order — `decorators[0]` is topmost. By Python's bottom-up application order, the topmost entry is the **outermost** decorator (applied last) and wraps the result of every decorator below it.\n *\n * Each entry should produce a complete decorator line (typically starting with `@`). Falsy entries (other than `0`) are skipped, so conditional decorators can be provided inline when needed.\n *\n * When used through wrappers that emit an intrinsic decorator (`ClassMethodDeclaration` → `@classmethod`, `StaticMethodDeclaration` → `@staticmethod`, `PropertyDeclaration` → `@property`), these decorators are rendered **above** the intrinsic line — the correct position for Pydantic's `@field_validator` / `@model_validator` and other wrappers that must see the underlying function, not a descriptor.\n *\n * When used on plain `MethodDeclaration` / `FunctionDeclaration`, these decorators are rendered above `@abstractmethod` (if `abstract` is set) and above `def`.\n *\n * Do **not** pass intrinsic decorators here — i.e. `@classmethod`, `@staticmethod`, `@property`, or `@abstractmethod`. Those are emitted by the matching component (`ClassMethodDeclaration`, `StaticMethodDeclaration`, `PropertyDeclaration`, or the `abstract` flag) and would otherwise be stacked twice in the output, producing invalid Python.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -2650,7 +2666,7 @@
         {
           "kind": "Variable",
           "canonicalReference": "@alloy-js/python!dataclassDecoratorKeys:var",
-          "docComment": "/**\n * Allowed keyword arguments for the Python `@dataclass(...)` decorator.\n * Single source of truth: runtime keys and compile-time type are derived here.\n */\n",
+          "docComment": "/**\n * Allowed keyword arguments for the Python `@dataclass(...)` decorator. Single source of truth: runtime keys and compile-time type are derived here.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -2787,7 +2803,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!Declaration:function(1)",
-          "docComment": "/**\n * A Python declaration, which can be a class, function, variable, etc.\n *\n * @remarks\n *\n *\n * This component is used to create a declaration with a symbol that can be\n * referenced in the code.\n */\n",
+          "docComment": "/**\n * A Python declaration, which can be a class, function, variable, etc.\n *\n * @remarks\n *\n * This component is used to create a declaration with a symbol that can be referenced in the code.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -3280,7 +3296,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!EnumMemberProps#refkey:member",
-              "docComment": "/**\n * Refkey for the enum member symbol. If the refkey is not provided, a symbol\n * will be created and the member cannot be referenced by refkey.\n */\n",
+              "docComment": "/**\n * Refkey for the enum member symbol. If the refkey is not provided, a symbol will be created and the member cannot be referenced by refkey.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -3400,7 +3416,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!EnumPropsBase#baseType:member",
-              "docComment": "/**\n * The base type of the enum. One of: 'Enum', 'IntEnum', 'StrEnum', 'Flag', 'IntFlag'.\n * Defaults to 'Enum'.\n */\n",
+              "docComment": "/**\n * The base type of the enum. One of: 'Enum', 'IntEnum', 'StrEnum', 'Flag', 'IntFlag'. Defaults to 'Enum'.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -3832,7 +3848,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!FunctionalEnumDeclaration:function(1)",
-          "docComment": "/**\n * Create a Python enum using the functional syntax.\n *\n * This generates enums using the `Enum('Name', [...])` or `Enum('Name', {...})` syntax.\n * The format depends on whether enum members have explicit values:\n * - Members without values: `Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])`\n * - Members with values: `Enum('Direction', {'NORTH': 1, 'SOUTH': 2, 'EAST': 3, 'WEST': 4})`\n *\n * @example\n * ```tsx\n * <FunctionalEnumDeclaration\n *   name=\"Direction\"\n *   members={[\n *     { name: \"NORTH\" },\n *     { name: \"SOUTH\" },\n *     { name: \"EAST\" },\n *     { name: \"WEST\" }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * Direction = Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])\n * ```\n *\n * @example\n * ```tsx\n * <FunctionalEnumDeclaration\n *   name=\"Status\"\n *   members={[\n *     { name: \"PENDING\", value: 1 },\n *     { name: \"ACTIVE\", value: 2 },\n *     { name: \"INACTIVE\", value: 3 }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * Status = Enum('Status', {'PENDING': 1, 'ACTIVE': 2, 'INACTIVE': 3})\n * ```\n *\n */\n",
+          "docComment": "/**\n * Create a Python enum using the functional syntax.\n *\n * This generates enums using the `Enum('Name', [...])` or `Enum('Name', {...})` syntax. The format depends on whether enum members have explicit values: - Members without values: `Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])` - Members with values: `Enum('Direction', {'NORTH': 1, 'SOUTH': 2, 'EAST': 3, 'WEST': 4})`\n *\n * @example\n * ```tsx\n * <FunctionalEnumDeclaration\n *   name=\"Direction\"\n *   members={[\n *     { name: \"NORTH\" },\n *     { name: \"SOUTH\" },\n *     { name: \"EAST\" },\n *     { name: \"WEST\" }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * Direction = Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])\n * ```\n *\n * @example\n * ```tsx\n * <FunctionalEnumDeclaration\n *   name=\"Status\"\n *   members={[\n *     { name: \"PENDING\", value: 1 },\n *     { name: \"ACTIVE\", value: 2 },\n *     { name: \"INACTIVE\", value: 3 }\n *   ]}\n * />\n * ```\n *\n * renders to:\n * ```python\n * Status = Enum('Status', {'PENDING': 1, 'ACTIVE': 2, 'INACTIVE': 3})\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -4035,7 +4051,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!FunctionDeclaration:function(1)",
-          "docComment": "/**\n * A Python function declaration.\n *\n * @remarks\n *\n *\n * This component creates a Python function declaration with optional type annotations,\n * parameters, and return types. It supports async functions and automatically\n * handles symbol creation and emission.\n *\n * @example\n * ```tsx\n * <FunctionDeclaration\n *   name=\"my_function\"\n *   returnType=\"int\"\n *   parameters={[{ name: \"a\", type: { children: \"int\" } }, { name: \"b\", type: { children: \"str\" } }]}\n * >\n *   return a + b\n * </FunctionDeclaration>\n * ```\n *\n * This will generate:\n * ```python\n * def my_function(a: int, b: str) -> int:\n *     return a + b\n * ```\n *\n */\n",
+          "docComment": "/**\n * A Python function declaration.\n *\n * @remarks\n *\n * This component creates a Python function declaration with optional type annotations, parameters, and return types. It supports async functions and automatically handles symbol creation and emission.\n *\n * @example\n * ```tsx\n * <FunctionDeclaration\n *   name=\"my_function\"\n *   returnType=\"int\"\n *   parameters={[{ name: \"a\", type: { children: \"int\" } }, { name: \"b\", type: { children: \"str\" } }]}\n * >\n *   return a + b\n * </FunctionDeclaration>\n * ```\n *\n * This will generate:\n * ```python\n * def my_function(a: int, b: str) -> int:\n *     return a + b\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -4494,7 +4510,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!FutureStatement:function(1)",
-          "docComment": "/**\n * A future statement that imports features from __future__.\n *\n * Future statements are directives to the compiler that a particular module\n * should be compiled using syntax or semantics from a future Python release.\n * They must appear near the top of the module, after the module docstring (if any).\n *\n * Use this in the `futureImports` prop of SourceFile to ensure proper placement.\n *\n * @example\n * ```tsx\n * <SourceFile path=\"models.py\" futureImports={[<FutureStatement feature=\"annotations\" />]}>\n *   <ClassDeclaration name=\"User\">\n *     <PropertyDeclaration name=\"manager\" type=\"User\" />\n *   </ClassDeclaration>\n * </SourceFile>\n * ```\n *\n * renders to\n * ```py\n * from __future__ import annotations\n *\n *\n * class User:\n *     manager: User\n * ```\n *\n */\n",
+          "docComment": "/**\n * A future statement that imports features from __future__.\n *\n * Future statements are directives to the compiler that a particular module should be compiled using syntax or semantics from a future Python release. They must appear near the top of the module, after the module docstring (if any).\n *\n * Use this in the `futureImports` prop of SourceFile to ensure proper placement.\n *\n * @example\n * ```tsx\n * <SourceFile path=\"models.py\" futureImports={[<FutureStatement feature=\"annotations\" />]}>\n *   <ClassDeclaration name=\"User\">\n *     <PropertyDeclaration name=\"manager\" type=\"User\" />\n *   </ClassDeclaration>\n * </SourceFile>\n * ```\n *\n * renders to\n * ```py\n * from __future__ import annotations\n *\n *\n * class User:\n *     manager: User\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -4936,7 +4952,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!getCallSignatureProps:function(1)",
-          "docComment": "/**\n * Extract only the call signature props from a props object which extends\n * `CallSignatureProps`. You can provide default values for the props.\n */\n",
+          "docComment": "/**\n * Extract only the call signature props from a props object which extends `CallSignatureProps`. You can provide default values for the props.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -5425,7 +5441,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!InlineDoc:function(1)",
-          "docComment": "/**\n * An inline documentation component for attribute docstrings.\n * Unlike PyDoc, this doesn't add a trailing line break after the closing quotes,\n * which is appropriate for documenting consecutive attributes like enum members.\n */\n",
+          "docComment": "/**\n * An inline documentation component for attribute docstrings. Unlike PyDoc, this doesn't add a trailing line break after the closing quotes, which is appropriate for documenting consecutive attributes like enum members.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -5573,7 +5589,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!isTypeRefContext:function(1)",
-          "docComment": "/**\n * @returns  'true' if in a type context, 'false' if in a value context.\n */\n",
+          "docComment": "/**\n * @returns 'true' if in a type context, 'false' if in a value context.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -5750,7 +5766,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!MemberExpression:function(1)",
-          "docComment": "/**\n * Create a member expression from parts. Each part can provide one of\n * the following:\n *\n * * **id**: The identifier for the member expression part\n * * **refkey**: a refkey for a symbol whose name becomes the identifier\n * * **symbol**: a symbol whose name becomes the identifier part\n * * **args**: create a method call with the given args\n * * **children**: arbitrary contents for the identifier part.\n *\n * @example\n *\n *\n *\n * ```tsx\n * <MemberExpression>\n *   <MemberExpression.Part id=\"base\" />\n *   <MemberExpression.Part refkey={rk} />\n *   <MemberExpression.Part symbol={sym} />\n *   <MemberExpression.Part args={[\"hello\", \"world\"]} />\n *   <MemberExpression.Part>SomeValue</MemberExpression.Part>\n * </MemberExpression>\n * ```\n *\n *\n * Assuming `rk` is a refkey to a symbol name \"prop1\", and `sym` is a symbol\n * with a name of \"prop2\", this will render:\n *\n * ```ts\n * base.prop1.prop2(\"hello\", \"world\").SomeValue\n * ```\n *\n */\n",
+          "docComment": "/**\n * Create a member expression from parts. Each part can provide one of the following:\n *\n * * **id**: The identifier for the member expression part * **refkey**: a refkey for a symbol whose name becomes the identifier * **symbol**: a symbol whose name becomes the identifier part * **args**: create a method call with the given args * **children**: arbitrary contents for the identifier part.\n *\n * @example\n * ```tsx\n * <MemberExpression>\n *   <MemberExpression.Part id=\"base\" />\n *   <MemberExpression.Part refkey={rk} />\n *   <MemberExpression.Part symbol={sym} />\n *   <MemberExpression.Part args={[\"hello\", \"world\"]} />\n *   <MemberExpression.Part>SomeValue</MemberExpression.Part>\n * </MemberExpression>\n * ```\n *\n * Assuming `rk` is a refkey to a symbol name \"prop1\", and `sym` is a symbol with a name of \"prop2\", this will render:\n * ```ts\n * base.prop1.prop2(\"hello\", \"world\").SomeValue\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -5902,7 +5918,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!MemberExpressionPartProps#id:member",
-              "docComment": "/**\n * The identifier for attribute access (obj.attr).\n * Use this for Python attribute references.\n */\n",
+              "docComment": "/**\n * The identifier for attribute access (obj.attr). Use this for Python attribute references.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -5929,7 +5945,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!MemberExpressionPartProps#key:member",
-              "docComment": "/**\n * Single key for subscription access (obj[key] or obj[0]).\n * Use this for single subscription access.\n */\n",
+              "docComment": "/**\n * Single key for subscription access (obj[key] or obj[0]). Use this for single subscription access.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -5957,7 +5973,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!MemberExpressionPartProps#keys:member",
-              "docComment": "/**\n * Multiple keys for tuple subscription access (obj[a, b] -\\> obj[(a, b)]).\n * Use this when you need tuple key access.\n */\n",
+              "docComment": "/**\n * Multiple keys for tuple subscription access (obj[a, b] -\\> obj[(a, b)]). Use this when you need tuple key access.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -6017,7 +6033,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!MemberExpressionPartProps#slice:member",
-              "docComment": "/**\n * Slice notation for subscription access (obj[start:stop:step]).\n * Use this for Python slice syntax.\n */\n",
+              "docComment": "/**\n * Slice notation for subscription access (obj[start:stop:step]). Use this for Python slice syntax.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -6269,7 +6285,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!MethodDeclaration:function(1)",
-          "docComment": "/**\n * A Python instance method declaration component.\n *\n * @remarks\n *\n *\n * Automatically injects the `self` parameter for instance methods and enforces\n * that the declaration appears within a class body.\n *\n * @example\n * ```tsx\n * <py.MethodDeclaration name=\"do_work\" parameters={[{ name: \"value\", type: \"int\" }]}>\n *   return value * 2\n * </py.MethodDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * def do_work(self, value: int) -> None:\n *     return value * 2\n * ```\n *\n */\n",
+          "docComment": "/**\n * A Python instance method declaration component.\n *\n * @remarks\n *\n * Automatically injects the `self` parameter for instance methods and enforces that the declaration appears within a class body.\n *\n * @example\n * ```tsx\n * <py.MethodDeclaration name=\"do_work\" parameters={[{ name: \"value\", type: \"int\" }]}>\n *   return value * 2\n * </py.MethodDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * def do_work(self, value: int) -> None:\n *     return value * 2\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -6379,7 +6395,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!MethodDoc:function(1)",
-          "docComment": "/**\n * A component that creates a MethodDoc block for class methods.\n * Automatically adds a note about not including 'self' parameter if no custom note is provided.\n */\n",
+          "docComment": "/**\n * A component that creates a MethodDoc block for class methods. Automatically adds a note about not including 'self' parameter if no custom note is provided.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -7684,7 +7700,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/python!PropertyDeclarationProps:interface",
-          "docComment": "/**\n * Declares a Python property with optional getter, setter, and deleter methods.\n *\n * @remarks\n *\n *\n * The property must be declared within a class. The getter method is\n * automatically generated using the `@property` decorator. Use the nested\n * `Setter` and `Deleter` components to add mutators.\n *\n * Use **`decorators`** for decorators that must appear **above** the intrinsic\n * `@property` (for example Pydantic `@computed_field`, `@typing.final`,\n * `@typing.override`). The first array entry is rendered topmost, matching\n * Python source order.\n *\n * @example\n * ```tsx\n * <py.PropertyDeclaration name=\"name\" type={{ children: \"str\" }}>\n *   return self._name\n * </py.PropertyDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @property\n * def name(self) -> str:\n *     return self._name\n * ```\n *\n * @example\n *\n *  Setter and deleter\n * ```tsx\n * <py.PropertyDeclaration name=\"value\" type={{ children: \"int\" }}>\n *   return self._value\n *   <py.PropertyDeclaration.Setter type={{ children: \"int\" }}>\n *     self._value = value\n *   </py.PropertyDeclaration.Setter>\n *   <py.PropertyDeclaration.Deleter>\n *     del self._value\n *   </py.PropertyDeclaration.Deleter>\n * </py.PropertyDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @property\n * def value(self) -> int:\n *     return self._value\n *\n * @value.setter\n * def value(self, value: int) -> None:\n *     self._value = value\n *\n * @value.deleter\n * def value(self) -> None:\n *     del self._value\n * ```\n *\n * @example\n *\n *  Pydantic computed field\n * ```tsx\n * <py.PropertyDeclaration\n *   name=\"area\"\n *   type=\"float\"\n *   decorators={[code`@${pydanticModule[\".\"].computed_field}`]}\n * >\n *   return self.width ** 2\n * </py.PropertyDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @computed_field\n * @property\n * def area(self) -> float:\n *     return self.width ** 2\n * ```\n *\n */\n",
+          "docComment": "/**\n * Declares a Python property with optional getter, setter, and deleter methods.\n *\n * @remarks\n *\n * The property must be declared within a class. The getter method is automatically generated using the `@property` decorator. Use the nested `Setter` and `Deleter` components to add mutators.\n *\n * Use **`decorators`** for decorators that must appear **above** the intrinsic `@property` (for example Pydantic `@computed_field`, `@typing.final`, `@typing.override`). The first array entry is rendered topmost, matching Python source order.\n *\n * @example\n * ```tsx\n * <py.PropertyDeclaration name=\"name\" type={{ children: \"str\" }}>\n *   return self._name\n * </py.PropertyDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @property\n * def name(self) -> str:\n *     return self._name\n * ```\n *\n * @example\n *\n * Setter and deleter\n * ```tsx\n * <py.PropertyDeclaration name=\"value\" type={{ children: \"int\" }}>\n *   return self._value\n *   <py.PropertyDeclaration.Setter type={{ children: \"int\" }}>\n *     self._value = value\n *   </py.PropertyDeclaration.Setter>\n *   <py.PropertyDeclaration.Deleter>\n *     del self._value\n *   </py.PropertyDeclaration.Deleter>\n * </py.PropertyDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @property\n * def value(self) -> int:\n *     return self._value\n *\n * @value.setter\n * def value(self, value: int) -> None:\n *     self._value = value\n *\n * @value.deleter\n * def value(self) -> None:\n *     del self._value\n * ```\n *\n * @example\n *\n * Pydantic computed field\n * ```tsx\n * <py.PropertyDeclaration\n *   name=\"area\"\n *   type=\"float\"\n *   decorators={[code`@${pydanticModule[\".\"].computed_field}`]}\n * >\n *   return self.width ** 2\n * </py.PropertyDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @computed_field\n * @property\n * def area(self) -> float:\n *     return self.width ** 2\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -7754,7 +7770,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!PropertyDeclarationProps#decorators:member",
-              "docComment": "/**\n * Decorators rendered above the intrinsic `@property` line, in source order\n * (`decorators[0]` is topmost / applied last). Use for decorators that wrap\n * the resulting property, e.g. Pydantic's `@computed_field`.\n */\n",
+              "docComment": "/**\n * Decorators rendered above the intrinsic `@property` line, in source order (`decorators[0]` is topmost / applied last). Use for decorators that wrap the resulting property, e.g. Pydantic's `@computed_field`.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -8263,7 +8279,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!PydanticClassDeclaration:function(1)",
-          "docComment": "/**\n * Renders a Python class that subclasses Pydantic's `BaseModel`:\n * `class Name(BaseModel): ...`.\n *\n * When `bases` is omitted, the class extends `pydanticModule[\".\"].BaseModel`.\n * Pass `bases` to inherit from another generated class (or to combine bases explicitly).\n *\n * Optional `modelConfig={{...}}` and top-level config props (for example\n * `frozen`, `strict`, `extra`) emit `model_config = ConfigDict(...)` for common\n * Pydantic v2 model settings (see {@link PydanticModelConfigDictProps}).\n * When both are used, top-level props override `modelConfig` keys.\n *\n * Fields are ordinary class body declarations; use `pydanticModule[\".\"].Field` in\n * initializers when you need `Field(...)`.\n *\n * @example\n * ```tsx\n * import { pydanticModule } from \"@alloy-js/python\";\n * import * as py from \"@alloy-js/python\";\n *\n * <py.PydanticClassDeclaration name=\"User\" frozen>\n *   <py.VariableDeclaration instanceVariable omitNone name=\"id\" type=\"int\" />\n *   <py.VariableDeclaration\n *     instanceVariable\n *     name=\"name\"\n *     type=\"str\"\n *     initializer={\"Field(default=\\\"anonymous\\\")\"}\n *   />\n * </py.PydanticClassDeclaration>\n * ```\n *\n * ```py\n * from pydantic import BaseModel\n * from pydantic import ConfigDict\n * from pydantic import Field\n *\n * class User(BaseModel):\n *     model_config = ConfigDict(frozen=True)\n *     id: int\n *     name: str = Field(default=\"anonymous\")\n * ```\n *\n */\n",
+          "docComment": "/**\n * Renders a Python class that subclasses Pydantic's `BaseModel`: `class Name(BaseModel): ...`.\n *\n * When `bases` is omitted, the class extends `pydanticModule[\".\"].BaseModel`. Pass `bases` to inherit from another generated class (or to combine bases explicitly).\n *\n * Optional `modelConfig={{...}}` and top-level config props (for example `frozen`, `strict`, `extra`) emit `model_config = ConfigDict(...)` for common Pydantic v2 model settings (see {@link PydanticModelConfigDictProps}). When both are used, top-level props override `modelConfig` keys.\n *\n * Fields are ordinary class body declarations; use `pydanticModule[\".\"].Field` in initializers when you need `Field(...)`.\n *\n * @example\n * ```tsx\n * import { pydanticModule } from \"@alloy-js/python\";\n * import * as py from \"@alloy-js/python\";\n *\n * <py.PydanticClassDeclaration name=\"User\" frozen>\n *   <py.VariableDeclaration instanceVariable omitNone name=\"id\" type=\"int\" />\n *   <py.VariableDeclaration\n *     instanceVariable\n *     name=\"name\"\n *     type=\"str\"\n *     initializer={\"Field(default=\\\"anonymous\\\")\"}\n *   />\n * </py.PydanticClassDeclaration>\n * ```\n *\n * ```py\n * from pydantic import BaseModel\n * from pydantic import ConfigDict\n * from pydantic import Field\n *\n * class User(BaseModel):\n *     model_config = ConfigDict(frozen=True)\n *     id: int\n *     name: str = Field(default=\"anonymous\")\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -8343,7 +8359,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!PydanticClassDeclarationProps#modelConfig:member",
-              "docComment": "/**\n * Canonical structured config object for `ConfigDict(...)`. Values here are\n * merged with top-level config props.\n *\n * Top-level config props take precedence over `modelConfig` when the same key\n * is provided in both places.\n */\n",
+              "docComment": "/**\n * Canonical structured config object for `ConfigDict(...)`. Values here are merged with top-level config props.\n *\n * Top-level config props take precedence over `modelConfig` when the same key is provided in both places.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -8371,7 +8387,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!PydanticClassDeclarationProps#modelConfigExpression:member",
-              "docComment": "/**\n * Emits `model_config = <expression>` verbatim (use for arbitrary `ConfigDict`\n * kwargs or dynamic config). Takes precedence over both `modelConfig` and\n * top-level config props.\n *\n * @example\n *\n *\n * A typical value emits `ConfigDict(frozen=True, extra=\"forbid\")`.\n */\n",
+              "docComment": "/**\n * Emits `model_config = <expression>` verbatim (use for arbitrary `ConfigDict` kwargs or dynamic config). Takes precedence over both `modelConfig` and top-level config props.\n *\n * @example\n *\n * A typical value emits `ConfigDict(frozen=True, extra=\"forbid\")`.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -8411,7 +8427,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/python!PydanticModelConfigDictProps:interface",
-          "docComment": "/**\n * Keyword-style options for Pydantic v2 `ConfigDict`, using camelCase prop names\n * that map to snake_case Python arguments (for example `validateAssignment` →\n * `validate_assignment`).\n */\n",
+          "docComment": "/**\n * Keyword-style options for Pydantic v2 `ConfigDict`, using camelCase prop names that map to snake_case Python arguments (for example `validateAssignment` → `validate_assignment`).\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -9156,7 +9172,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!PyDoc:function(1)",
-          "docComment": "/**\n * A PyDoc comment. The children of this component are joined with two hard\n * linebreaks. This is useful for creating PyDoc comments with multiple paragraphs.\n */\n",
+          "docComment": "/**\n * A PyDoc comment. The children of this component are joined with two hard linebreaks. This is useful for creating PyDoc comments with multiple paragraphs.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -9787,7 +9803,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@alloy-js/python!PythonModuleScope#addTypeImport:member(1)",
-              "docComment": "/**\n * Add TYPE_CHECKING import from the typing module.\n * Returns the local symbol for use in the if block opener.\n */\n",
+              "docComment": "/**\n * Add TYPE_CHECKING import from the typing module. Returns the local symbol for use in the if block opener.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -10261,7 +10277,7 @@
             {
               "kind": "Property",
               "canonicalReference": "@alloy-js/python!PythonOutputSymbol#isTypeOnly:member",
-              "docComment": "/**\n * Returns true if this symbol is only used in type annotation contexts.\n * Such symbols can be imported inside a TYPE_CHECKING block.\n */\n",
+              "docComment": "/**\n * Returns true if this symbol is only used in type annotation contexts. Such symbols can be imported inside a TYPE_CHECKING block.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -10701,11 +10717,11 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!Reference:function(1)",
-          "docComment": "/**\n * A Python reference to a symbol, such as a variable, function, or class.\n *\n * @remarks\n *\n *\n * This component is used to render references to symbols in Python code.\n * It takes a `refkey` prop which is the key of the symbol to reference.\n */\n",
+          "docComment": "/**\n * A Python reference to a symbol, such as a variable, function, or class.\n *\n * @remarks\n *\n * This component is used to render references to symbols in Python code. It takes a `refkey` prop which is the key of the symbol to reference.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
-              "text": "export declare function Reference({ refkey }: "
+              "text": "export declare function Reference(input: "
             },
             {
               "kind": "Reference",
@@ -10740,6 +10756,14 @@
           "parameters": [
             {
               "parameterName": "{ refkey }",
+              "parameterTypeTokenRange": {
+                "startIndex": 0,
+                "endIndex": 0
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "input",
               "parameterTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -10813,7 +10837,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!RefOptions#type:member",
-              "docComment": "/**\n * If true, this reference is only used in a type annotation context.\n * The import will be guarded with `if TYPE_CHECKING:`.\n */\n",
+              "docComment": "/**\n * If true, this reference is only used in a type annotation context. The import will be guarded with `if TYPE_CHECKING:`.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -11066,7 +11090,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!SourceFile:function(1)",
-          "docComment": "/**\n * A Python source file component that represents a Python file in the source directory.\n * It provides a scope for the file, which is a `PythonModuleScope` that contains\n * all the symbols defined in the file, such as functions, classes, and variables.\n *\n * @example\n * ```tsx\n * <SourceFile path=\"test.py\">\n *   <FunctionDeclaration name=\"test\" />\n * </SourceFile>\n * ```\n *\n * renders to\n * ```py\n * def test():\n *   pass\n * ```\n *\n * @example\n *\n *\n * With module documentation:\n * ```tsx\n * <SourceFile\n *   path=\"utils.py\"\n *   doc={<ModuleDoc description={[<Prose>Utility functions for data processing.</Prose>]} />}\n * >\n *   <FunctionDeclaration name=\"process_data\" />\n * </SourceFile>\n * ```\n *\n * renders to\n * ```py\n * \"\"\"\n * Utility functions for data processing.\n * \"\"\"\n *\n * def process_data():\n *   pass\n * ```\n *\n */\n",
+          "docComment": "/**\n * A Python source file component that represents a Python file in the source directory. It provides a scope for the file, which is a `PythonModuleScope` that contains all the symbols defined in the file, such as functions, classes, and variables.\n *\n * @example\n * ```tsx\n * <SourceFile path=\"test.py\">\n *   <FunctionDeclaration name=\"test\" />\n * </SourceFile>\n * ```\n *\n * renders to\n * ```py\n * def test():\n *   pass\n * ```\n *\n * @example\n *\n * With module documentation:\n * ```tsx\n * <SourceFile\n *   path=\"utils.py\"\n *   doc={<ModuleDoc description={[<Prose>Utility functions for data processing.</Prose>]} />}\n * >\n *   <FunctionDeclaration name=\"process_data\" />\n * </SourceFile>\n * ```\n *\n * renders to\n * ```py\n * \"\"\"\n * Utility functions for data processing.\n * \"\"\"\n *\n * def process_data():\n *   pass\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -11225,7 +11249,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!SourceFileProps#header:member",
-              "docComment": "/**\n * Content to render at the very top of the file, before everything else.\n * Use this for shebang lines, encoding declarations, or license headers.\n */\n",
+              "docComment": "/**\n * Content to render at the very top of the file, before everything else. Use this for shebang lines, encoding declarations, or license headers.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -11253,7 +11277,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!SourceFileProps#headerComment:member",
-              "docComment": "/**\n * Comment to add at the top of the file, rendered as a Python comment block.\n * This is a convenience prop for adding copyright notices or other comments.\n */\n",
+              "docComment": "/**\n * Comment to add at the top of the file, rendered as a Python comment block. This is a convenience prop for adding copyright notices or other comments.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -11315,7 +11339,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!StatementList:function(1)",
-          "docComment": "/**\n * A Python statement list, which is a list of statements that can be rendered\n * in a Python source file.\n *\n * @example\n * ```tsx\n * <StatementList>\n *   <FunctionDeclaration name=\"test\" />\n *   <VariableDeclaration name=\"x\" value={42} />\n * </StatementList>\n * ```\n *\n * renders to\n * ```py\n * def test():\n *   pass\n *\n * x = 42\n * ```\n *\n */\n",
+          "docComment": "/**\n * A Python statement list, which is a list of statements that can be rendered in a Python source file.\n *\n * @example\n * ```tsx\n * <StatementList>\n *   <FunctionDeclaration name=\"test\" />\n *   <VariableDeclaration name=\"x\" value={42} />\n * </StatementList>\n * ```\n *\n * renders to\n * ```py\n * def test():\n *   pass\n *\n * x = 42\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -11459,7 +11483,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/python!StaticMethodDeclarationProps:interface",
-          "docComment": "/**\n * A Python static method declaration component.\n *\n * @remarks\n *\n *\n * Use **`decorators`** for decorators that must appear above `@staticmethod`.\n *\n * @example\n * ```tsx\n * <py.StaticMethodDeclaration name=\"identity\" parameters={[{ name: \"value\", type: \"int\" }]}>\n *   return value\n * </py.StaticMethodDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @staticmethod\n * def identity(value: int) -> None:\n *     return value\n * ```\n *\n */\n",
+          "docComment": "/**\n * A Python static method declaration component.\n *\n * @remarks\n *\n * Use **`decorators`** for decorators that must appear above `@staticmethod`.\n *\n * @example\n * ```tsx\n * <py.StaticMethodDeclaration name=\"identity\" parameters={[{ name: \"value\", type: \"int\" }]}>\n *   return value\n * </py.StaticMethodDeclaration>\n * ```\n *\n * Generates:\n * ```python\n * @staticmethod\n * def identity(value: int) -> None:\n *     return value\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -11533,7 +11557,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!SubscriptionProps#key:member",
-              "docComment": "/**\n * Single key for subscription access (obj[key] or obj[0]).\n * Use this for single subscription access.\n */\n",
+              "docComment": "/**\n * Single key for subscription access (obj[key] or obj[0]). Use this for single subscription access.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -11561,7 +11585,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!SubscriptionProps#keys:member",
-              "docComment": "/**\n * Multiple keys for tuple subscription access (obj[a, b] -\\> obj[(a, b)]).\n * Use this when you need tuple key access.\n */\n",
+              "docComment": "/**\n * Multiple keys for tuple subscription access (obj[a, b] -\\> obj[(a, b)]). Use this when you need tuple key access.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -11593,7 +11617,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!SubscriptionProps#slice:member",
-              "docComment": "/**\n * Slice notation for subscription access (obj[start:stop:step]).\n * Use this for Python slice syntax.\n */\n",
+              "docComment": "/**\n * Slice notation for subscription access (obj[start:stop:step]). Use this for Python slice syntax.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -11747,11 +11771,11 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!TypeRefContext:function(1)",
-          "docComment": "/**\n * Set the current context of reference to be type reference.\n *\n * @remarks\n *\n *\n * References used inside the children of this component will be treated as\n * type-only references. When a symbol is only referenced in type contexts,\n * it will be imported inside a `if TYPE_CHECKING:` block.\n *\n * @example\n * ```tsx\n * <TypeRefContext>\n *   {someTypeRefkey}\n * </TypeRefContext>\n * ```\n *\n */\n",
+          "docComment": "/**\n * Set the current context of reference to be type reference.\n *\n * @remarks\n *\n * References used inside the children of this component will be treated as type-only references. When a symbol is only referenced in type contexts, it will be imported inside a `if TYPE_CHECKING:` block.\n *\n * @example\n * ```tsx\n * <TypeRefContext>\n *   {someTypeRefkey}\n * </TypeRefContext>\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
-              "text": "TypeRefContext: ({ children }: "
+              "text": "TypeRefContext: (input: "
             },
             {
               "kind": "Reference",
@@ -11778,6 +11802,14 @@
           "parameters": [
             {
               "parameterName": "{ children }",
+              "parameterTypeTokenRange": {
+                "startIndex": 0,
+                "endIndex": 0
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "input",
               "parameterTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -11836,7 +11868,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/python!TypeReference:function(1)",
-          "docComment": "/**\n * A type reference like Foo[T, P] or int.\n *\n * @remarks\n *\n *\n * This component automatically wraps its content in a type reference context,\n * so any symbols referenced via refkey will be imported as type-only\n * (inside a `if TYPE_CHECKING:` block) unless also used as values elsewhere.\n */\n",
+          "docComment": "/**\n * A type reference like Foo[T, P] or int.\n *\n * @remarks\n *\n * This component automatically wraps its content in a type reference context, so any symbols referenced via refkey will be imported as type-only (inside a `if TYPE_CHECKING:` block) unless also used as values elsewhere.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -12328,7 +12360,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!VariableDeclarationProps#callStatementVar:member",
-              "docComment": "/**\n * Indicates if this is a call statement variable. Optional.\n * This is used to handle cases where the variable is part of a call statement.\n */\n",
+              "docComment": "/**\n * Indicates if this is a call statement variable. Optional. This is used to handle cases where the variable is part of a call statement.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -12383,7 +12415,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/python!VariableDeclarationProps#instanceVariable:member",
-              "docComment": "/**\n * Indicates if this variable is an instance variable. Optional.\n * This is used to handle cases where the variable is part of a class instance.\n */\n",
+              "docComment": "/**\n * Indicates if this variable is an instance variable. Optional. This is used to handle cases where the variable is part of a class instance.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",