@hey-api/openapi-python 0.0.23 → 0.0.24

package/dist/index.d.mts

@@ -1,7 +1,8 @@
-import { a as PydanticPlugin, c as HeyApiClientHttpxPlugin, n as plugins_d_exports, o as PydanticResolvers, s as HeyApiSdkPlugin } from "./plugins-BDUY2dP5.mjs";
-import { Logger, Logger as Logger$1, Version } from "@hey-api/codegen-core";
-import { AnyPluginName, BaseUserConfig, BaseUserOutput, Coercer, CoercerMap, ConfigTable, Context, DefinePlugin, IR, OpenApi, OpenApiMetaObject, OpenApiOperationObject, OpenApiParameterObject, OpenApiRequestBodyObject, OpenApiResponseObject, OpenApiSchemaObject, OperationPath, OperationStrategy, Plugin, Plugin as Plugin$1, PluginConfigMap, PluginContext, PluginInstance, PluginNames, SymbolFactory, TableDirectives, UserPostProcessor, applyNaming, coerce, defaultPaginationKeywords, defineConfig as defineConfigTable, definePluginConfig, toCase, utils } from "@hey-api/shared";
-import { AnyString, LazyOrAsync, MaybeArray } from "@hey-api/types";
+import { t as plugins_d_exports } from "./plugins.mjs";
+import { AnalysisContext, BindingKind, File, FromRef, Language, Logger, Node as Node$1, NodeName as NodeName$1, NodeNameSanitizer, NodeRelationship, NodeScope, ProjectMeta, Ref, Symbol, Version } from "@hey-api/codegen-core";
+import { AnyPluginName, BaseUserConfig, BaseUserOutput, Casing, Coercer, CoercerMap, ConfigTable, Context, DefinePlugin as DefinePlugin$1, DefinePlugin as DefinePlugin$2, FeatureToggle, IR, IR as IR$1, NameTransformer, NamingConfig, NamingOptions, NamingRule, OpenApi, OpenApiMetaObject, OpenApiOperationObject, OpenApiParameterObject, OpenApiRequestBodyObject, OpenApiResponseObject, OpenApiSchemaObject, OperationPath, OperationPathStrategy, OperationStrategy, OperationsStrategy, Plugin, Plugin as Plugin$1, PluginConfigMap, PluginContext, PluginInstance, PluginInstance as PluginInstance$1, PluginNames, SchemaVisitorContext, SchemaWithType, SymbolFactory, TableDirectives, UserPostProcessor, Walker, applyNaming, coerce, defaultPaginationKeywords, defineConfig as defineConfigTable, definePluginConfig, toCase, utils } from "@hey-api/shared";
+import { AnyString, LazyOrAsync, MaybeArray, MaybeFunc } from "@hey-api/types";
+import { LinguistLanguages } from "@hey-api/spec-types";
 
 //#region src/config/output/postprocess.d.ts
 declare const postProcessors: {
@@ -81,24 +82,2893 @@ type UserConfig = BaseUserConfig<UserOutput> & {
   } }[PluginNames]>;
 };
 //#endregion
+//#region src/plugins/@hey-api/client-httpx/types.d.ts
+type UserConfig$3 = Plugin$1.Name<'@hey-api/client-httpx'> & {
+  /**
+   * Set a default base URL when creating the client? You can set `baseUrl`
+   * to a string which will be used as the base URL. If your input defines
+   * server(s), you can set `baseUrl` to a number to pick a specific server
+   * to use as the base URL. You can disable setting the base URL by setting
+   * `baseUrl` to `false`. By default, `baseUrl` is `true` and it will try to
+   * use the first defined server value. If there's none, we won't set a
+   * base URL.
+   *
+   * If the matched URL contains template literals, it will be ignored.
+   *
+   * @default true
+   */
+  baseUrl?: string | number | boolean;
+};
+type Config$2 = Plugin$1.Name<'@hey-api/client-httpx'> & {
+  baseUrl: string | number | boolean;
+};
+type HeyApiClientHttpxPlugin = DefinePlugin$2<UserConfig$3, Config$2>;
+//#endregion
+//#region src/plugins/types.d.ts
+type PluginClientNames = '@hey-api/client-aiohttp' | '@hey-api/client-httpx' | '@hey-api/client-requests' | '@hey-api/client-urllib3';
+//#endregion
+//#region src/py-compiler/nodes/kinds.d.ts
+declare enum PyNodeKind {
+  Assignment = "Assignment",
+  AsyncExpression = "AsyncExpression",
+  AugmentedAssignment = "AugmentedAssignment",
+  AwaitExpression = "AwaitExpression",
+  BinaryExpression = "BinaryExpression",
+  Block = "Block",
+  BreakStatement = "BreakStatement",
+  CallExpression = "CallExpression",
+  ClassDeclaration = "ClassDeclaration",
+  Comment = "Comment",
+  ContinueStatement = "ContinueStatement",
+  DictComprehension = "DictComprehension",
+  DictExpression = "DictExpression",
+  EmptyStatement = "EmptyStatement",
+  ExceptClause = "ExceptClause",
+  ExpressionStatement = "ExpressionStatement",
+  FStringExpression = "FStringExpression",
+  ForStatement = "ForStatement",
+  FunctionDeclaration = "FunctionDeclaration",
+  FunctionParameter = "FunctionParameter",
+  GeneratorExpression = "GeneratorExpression",
+  Identifier = "Identifier",
+  IfStatement = "IfStatement",
+  ImportStatement = "ImportStatement",
+  KeywordArgument = "KeywordArgument",
+  LambdaExpression = "LambdaExpression",
+  ListComprehension = "ListComprehension",
+  ListExpression = "ListExpression",
+  Literal = "Literal",
+  MemberExpression = "MemberExpression",
+  RStringExpression = "RStringExpression",
+  RaiseStatement = "RaiseStatement",
+  ReturnStatement = "ReturnStatement",
+  SetComprehension = "SetComprehension",
+  SetExpression = "SetExpression",
+  SourceFile = "SourceFile",
+  SubscriptExpression = "SubscriptExpression",
+  SubscriptSlice = "SubscriptSlice",
+  TryStatement = "TryStatement",
+  TupleExpression = "TupleExpression",
+  WhileStatement = "WhileStatement",
+  WithItem = "WithItem",
+  WithStatement = "WithStatement",
+  YieldExpression = "YieldExpression",
+  YieldFromExpression = "YieldFromExpression"
+}
+//#endregion
+//#region src/py-compiler/nodes/statements/block.d.ts
+interface PyBlock extends PyNodeBase {
+  kind: PyNodeKind.Block;
+  statements: ReadonlyArray<PyStatement>;
+}
+declare function createBlock(statements: ReadonlyArray<PyStatement>, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyBlock;
+//#endregion
+//#region src/py-compiler/nodes/declarations/class.d.ts
+interface PyClassDeclaration extends PyNodeBase {
+  baseClasses?: ReadonlyArray<PyNode>;
+  body: PyBlock;
+  decorators?: ReadonlyArray<PyExpression>;
+  docstring?: string;
+  kind: PyNodeKind.ClassDeclaration;
+  name: string;
+}
+declare function createClassDeclaration(name: string, body: ReadonlyArray<PyStatement>, decorators?: ReadonlyArray<PyExpression>, baseClasses?: ReadonlyArray<PyNode>, docstring?: string, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyClassDeclaration;
+//#endregion
+//#region src/py-compiler/nodes/declarations/function-parameter.d.ts
+interface PyFunctionParameter extends PyNodeBase {
+  defaultValue?: PyExpression;
+  kind: PyNodeKind.FunctionParameter;
+  name: string;
+  type?: PyExpression;
+}
+declare function createFunctionParameter(name: string, type?: PyExpression, defaultValue?: PyExpression, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyFunctionParameter;
+//#endregion
+//#region src/py-compiler/nodes/declarations/function.d.ts
+interface PyFunctionDeclaration extends PyNodeBase {
+  body: PyBlock;
+  decorators?: ReadonlyArray<PyExpression>;
+  docstring?: string;
+  kind: PyNodeKind.FunctionDeclaration;
+  modifiers?: ReadonlyArray<PyExpression>;
+  name: string;
+  parameters: ReadonlyArray<PyFunctionParameter>;
+  returnType?: PyExpression;
+}
+declare function createFunctionDeclaration(name: string, parameters: ReadonlyArray<PyFunctionParameter>, returnType: PyExpression | undefined, body: ReadonlyArray<PyStatement>, decorators?: ReadonlyArray<PyExpression>, docstring?: string, modifiers?: ReadonlyArray<PyExpression>, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyFunctionDeclaration;
+//#endregion
+//#region src/py-compiler/nodes/statements/assignment.d.ts
+interface PyAssignment extends PyNodeBase {
+  kind: PyNodeKind.Assignment;
+  target: PyExpression;
+  type?: PyExpression;
+  value?: PyExpression;
+}
+declare function createAssignment(target: PyExpression, type?: PyExpression, value?: PyExpression, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyAssignment;
+//#endregion
+//#region src/py-compiler/nodes/statements/augmented-assignment.d.ts
+type PyAugmentedOperator = '+=' | '-=' | '*=' | '/=' | '//=' | '%=' | '**=' | '&=' | '|=' | '^=' | '>>=' | '<<=';
+interface PyAugmentedAssignment extends PyNodeBase {
+  kind: PyNodeKind.AugmentedAssignment;
+  operator: PyAugmentedOperator;
+  target: PyExpression;
+  value: PyExpression;
+}
+declare function createAugmentedAssignment(target: PyExpression, operator: PyAugmentedOperator, value: PyExpression): PyAugmentedAssignment;
+//#endregion
+//#region src/py-compiler/nodes/statements/break.d.ts
+interface PyBreakStatement extends PyNodeBase {
+  kind: PyNodeKind.BreakStatement;
+}
+declare function createBreakStatement(): PyBreakStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/continue.d.ts
+interface PyContinueStatement extends PyNodeBase {
+  kind: PyNodeKind.ContinueStatement;
+}
+declare function createContinueStatement(): PyContinueStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/empty.d.ts
+interface PyEmptyStatement extends PyNodeBase {
+  kind: PyNodeKind.EmptyStatement;
+}
+declare function createEmptyStatement(): PyEmptyStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/expression.d.ts
+interface PyExpressionStatement extends PyNodeBase {
+  expression: PyExpression;
+  kind: PyNodeKind.ExpressionStatement;
+}
+declare function createExpressionStatement(expression: PyExpression): PyExpressionStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/for.d.ts
+interface PyForStatement extends PyNodeBase {
+  body: PyBlock;
+  elseBlock?: PyBlock;
+  iterable: PyExpression;
+  kind: PyNodeKind.ForStatement;
+  target: PyExpression;
+}
+declare function createForStatement(target: PyExpression, iterable: PyExpression, body: ReadonlyArray<PyStatement>, elseBlock?: ReadonlyArray<PyStatement>): PyForStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/if.d.ts
+interface PyIfStatement extends PyNodeBase {
+  condition: PyExpression;
+  elseBlock?: PyBlock | PyIfStatement;
+  kind: PyNodeKind.IfStatement;
+  thenBlock: PyBlock;
+}
+declare function createIfStatement(condition: PyExpression, thenBlock: ReadonlyArray<PyStatement>, elseBlock?: ReadonlyArray<PyStatement> | PyIfStatement, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyIfStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/import.d.ts
+interface PyImportStatement extends PyNodeBase {
+  isFrom: boolean;
+  kind: PyNodeKind.ImportStatement;
+  module: string;
+  names?: ReadonlyArray<{
+    alias?: string;
+    name: string;
+  }>;
+}
+declare function createImportStatement(module: string, names?: ReadonlyArray<{
+  alias?: string;
+  name: string;
+}>, isFrom?: boolean): PyImportStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/raise.d.ts
+interface PyRaiseStatement extends PyNodeBase {
+  expression?: PyExpression;
+  kind: PyNodeKind.RaiseStatement;
+}
+declare function createRaiseStatement(expression?: PyExpression): PyRaiseStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/return.d.ts
+interface PyReturnStatement extends PyNodeBase {
+  expression?: PyExpression;
+  kind: PyNodeKind.ReturnStatement;
+}
+declare function createReturnStatement(expression?: PyExpression): PyReturnStatement;
+//#endregion
+//#region src/py-compiler/nodes/expressions/identifier.d.ts
+interface PyIdentifier extends PyNodeBase {
+  kind: PyNodeKind.Identifier;
+  name: string;
+}
+declare function createIdentifier(name: string, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyIdentifier;
+//#endregion
+//#region src/py-compiler/nodes/statements/except.d.ts
+interface PyExceptClause extends PyNodeBase {
+  block: PyBlock;
+  exceptionName?: PyIdentifier;
+  exceptionType?: PyExpression;
+  kind: PyNodeKind.ExceptClause;
+}
+declare function createExceptClause(block: ReadonlyArray<PyStatement>, exceptionType?: PyExpression, exceptionName?: PyIdentifier): PyExceptClause;
+//#endregion
+//#region src/py-compiler/nodes/statements/try.d.ts
+interface PyTryStatement extends PyNodeBase {
+  elseBlock?: PyBlock;
+  exceptClauses?: ReadonlyArray<PyExceptClause>;
+  finallyBlock?: PyBlock;
+  kind: PyNodeKind.TryStatement;
+  tryBlock: PyBlock;
+}
+declare function createTryStatement(tryBlock: ReadonlyArray<PyStatement>, exceptClauses?: ReadonlyArray<PyExceptClause>, elseBlock?: ReadonlyArray<PyStatement>, finallyBlock?: ReadonlyArray<PyStatement>): PyTryStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/while.d.ts
+interface PyWhileStatement extends PyNodeBase {
+  body: PyBlock;
+  condition: PyExpression;
+  elseBlock?: PyBlock;
+  kind: PyNodeKind.WhileStatement;
+}
+declare function createWhileStatement(condition: PyExpression, body: ReadonlyArray<PyStatement>, elseBlock?: ReadonlyArray<PyStatement>): PyWhileStatement;
+//#endregion
+//#region src/py-compiler/nodes/statements/with-item.d.ts
+interface PyWithItem extends PyNodeBase {
+  alias?: PyExpression;
+  contextExpr: PyExpression;
+  kind: PyNodeKind.WithItem;
+}
+declare function createWithItem(contextExpr: PyExpression, alias?: PyExpression, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyWithItem;
+//#endregion
+//#region src/py-compiler/nodes/statements/with.d.ts
+interface PyWithStatement extends PyNodeBase {
+  body: PyBlock;
+  items: ReadonlyArray<PyWithItem>;
+  kind: PyNodeKind.WithStatement;
+  modifiers?: ReadonlyArray<PyExpression>;
+}
+declare function createWithStatement(items: ReadonlyArray<PyWithItem>, body: ReadonlyArray<PyStatement>, modifiers?: ReadonlyArray<PyExpression>, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyWithStatement;
+//#endregion
+//#region src/py-compiler/nodes/structure/comment.d.ts
+interface PyComment extends PyNodeBase {
+  kind: PyNodeKind.Comment;
+  text: string;
+}
+declare function createComment(text: string): PyComment;
+//#endregion
+//#region src/py-compiler/nodes/statement.d.ts
+type PyStatement = PyAssignment | PyAugmentedAssignment | PyBreakStatement | PyClassDeclaration | PyComment | PyContinueStatement | PyEmptyStatement | PyExpressionStatement | PyForStatement | PyFunctionDeclaration | PyFunctionParameter | PyIfStatement | PyImportStatement | PyRaiseStatement | PyReturnStatement | PyTryStatement | PyWhileStatement | PyWithStatement;
+//#endregion
+//#region src/py-compiler/nodes/structure/source-file.d.ts
+interface PySourceFile extends PyNodeBase {
+  docstring?: string;
+  kind: PyNodeKind.SourceFile;
+  statements: ReadonlyArray<PyNode>;
+}
+declare function createSourceFile(statements: ReadonlyArray<PyNode>, docstring?: string, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PySourceFile;
+//#endregion
+//#region src/py-compiler/nodes/base.d.ts
+interface PyNodeBase {
+  kind: PyNodeKind;
+  leadingComments?: ReadonlyArray<string>;
+  trailingComments?: ReadonlyArray<string>;
+}
+type PyNode = PyBlock | PyExpression | PySourceFile | PyStatement;
+//#endregion
+//#region src/py-compiler/nodes/expressions/comprehensions/dict.d.ts
+interface PyDictComprehension extends PyComprehensionNode {
+  key: PyExpression;
+  kind: PyNodeKind.DictComprehension;
+  value: PyExpression;
+}
+declare function createDictComprehension(key: PyExpression, value: PyExpression, target: PyExpression, iterable: PyExpression, ifs?: ReadonlyArray<PyExpression>, isAsync?: boolean): PyDictComprehension;
+//#endregion
+//#region src/py-compiler/nodes/expressions/comprehensions/list.d.ts
+interface PyListComprehension extends PyComprehensionNode {
+  element: PyExpression;
+  kind: PyNodeKind.ListComprehension;
+}
+declare function createListComprehension(element: PyExpression, target: PyExpression, iterable: PyExpression, ifs?: ReadonlyArray<PyExpression>, isAsync?: boolean): PyListComprehension;
+//#endregion
+//#region src/py-compiler/nodes/expressions/comprehensions/set.d.ts
+interface PySetComprehension extends PyComprehensionNode {
+  element: PyExpression;
+  kind: PyNodeKind.SetComprehension;
+}
+declare function createSetComprehension(element: PyExpression, target: PyExpression, iterable: PyExpression, ifs?: ReadonlyArray<PyExpression>, isAsync?: boolean): PySetComprehension;
+//#endregion
+//#region src/py-compiler/nodes/comprehension.d.ts
+type PyComprehension = PyDictComprehension | PyListComprehension | PySetComprehension;
+interface PyComprehensionNode extends PyNodeBase {
+  ifs?: ReadonlyArray<PyExpression>;
+  isAsync?: boolean;
+  iterable: PyExpression;
+  target: PyExpression;
+}
+//#endregion
+//#region src/py-compiler/nodes/expressions/async.d.ts
+interface PyAsyncExpression extends PyNodeBase {
+  expression: PyExpression;
+  kind: PyNodeKind.AsyncExpression;
+}
+declare function createAsyncExpression(expression: PyExpression): PyAsyncExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/await.d.ts
+interface PyAwaitExpression extends PyNodeBase {
+  expression: PyExpression;
+  kind: PyNodeKind.AwaitExpression;
+}
+declare function createAwaitExpression(expression: PyExpression): PyAwaitExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/binary.d.ts
+type PyBinaryOperator = '+' | '-' | '*' | '/' | '//' | '%' | '**' | '==' | '!=' | '>' | '>=' | '<' | '<=' | 'is' | 'is not' | 'in' | 'not in' | 'and' | 'or' | '|' | '&' | '^' | '<<' | '>>';
+interface PyBinaryExpression extends PyNodeBase {
+  kind: PyNodeKind.BinaryExpression;
+  left: PyExpression;
+  operator: PyBinaryOperator;
+  right: PyExpression;
+}
+declare function createBinaryExpression(left: PyExpression, operator: PyBinaryOperator, right: PyExpression, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyBinaryExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/call.d.ts
+interface PyCallExpression extends PyNodeBase {
+  args: ReadonlyArray<PyExpression>;
+  callee: PyExpression;
+  kind: PyNodeKind.CallExpression;
+}
+declare function createCallExpression(callee: PyExpression, args: ReadonlyArray<PyExpression>, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyCallExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/dict.d.ts
+interface PyDictExpression extends PyNodeBase {
+  entries: ReadonlyArray<{
+    key: PyExpression;
+    value: PyExpression;
+  }>;
+  kind: PyNodeKind.DictExpression;
+}
+declare function createDictExpression(entries: ReadonlyArray<{
+  key: PyExpression;
+  value: PyExpression;
+}>): PyDictExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/f-string.d.ts
+interface PyFStringExpression extends PyNodeBase {
+  kind: PyNodeKind.FStringExpression;
+  parts: Array<string | PyExpression>;
+}
+declare function createFStringExpression(parts: Array<string | PyExpression>, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyFStringExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/generator.d.ts
+interface PyGeneratorExpression extends PyNodeBase {
+  element: PyExpression;
+  ifs?: ReadonlyArray<PyExpression>;
+  isAsync?: boolean;
+  iterable: PyExpression;
+  kind: PyNodeKind.GeneratorExpression;
+  target: PyExpression;
+}
+declare function createGeneratorExpression(element: PyExpression, target: PyExpression, iterable: PyExpression, ifs?: ReadonlyArray<PyExpression>, isAsync?: boolean, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyGeneratorExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/keyword-arg.d.ts
+interface PyKeywordArgument extends PyNodeBase {
+  kind: PyNodeKind.KeywordArgument;
+  name: string;
+  value: PyExpression;
+}
+declare function createKeywordArgument(name: string, value: PyExpression, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyKeywordArgument;
+//#endregion
+//#region src/py-compiler/nodes/expressions/lambda.d.ts
+interface PyLambdaExpression extends PyNodeBase {
+  expression: PyExpression;
+  kind: PyNodeKind.LambdaExpression;
+  parameters: ReadonlyArray<PyFunctionParameter>;
+}
+declare function createLambdaExpression(parameters: ReadonlyArray<PyFunctionParameter>, expression: PyExpression): PyLambdaExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/list.d.ts
+interface PyListExpression extends PyNodeBase {
+  elements: ReadonlyArray<PyNode>;
+  kind: PyNodeKind.ListExpression;
+}
+declare function createListExpression(elements: ReadonlyArray<PyNode>): PyListExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/literal.d.ts
+type PyLiteralValue = string | number | boolean | null;
+interface PyLiteral extends PyNodeBase {
+  kind: PyNodeKind.Literal;
+  value: PyLiteralValue;
+}
+declare function createLiteral(value: PyLiteralValue, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyLiteral;
+//#endregion
+//#region src/py-compiler/nodes/expressions/member.d.ts
+interface PyMemberExpression extends PyNodeBase {
+  kind: PyNodeKind.MemberExpression;
+  member: PyIdentifier;
+  object: PyExpression;
+}
+declare function createMemberExpression(object: PyExpression, member: PyIdentifier, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyMemberExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/r-string.d.ts
+interface PyRStringExpression extends PyNodeBase {
+  kind: PyNodeKind.RStringExpression;
+  value: string;
+}
+declare function createRStringExpression(value: string, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): PyRStringExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/set.d.ts
+interface PySetExpression extends PyNodeBase {
+  elements: ReadonlyArray<PyExpression>;
+  kind: PyNodeKind.SetExpression;
+}
+declare function createSetExpression(elements: ReadonlyArray<PyExpression>): PySetExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/subscript.d.ts
+interface PySubscriptExpression extends PyNodeBase {
+  kind: PyNodeKind.SubscriptExpression;
+  slice: PyExpression;
+  value: PyExpression;
+}
+declare function createSubscriptExpression(value: PyExpression, slice: PyExpression): PySubscriptExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/subscript-slice.d.ts
+interface PySubscriptSlice extends PyNodeBase {
+  elements: ReadonlyArray<PyExpression>;
+  kind: PyNodeKind.SubscriptSlice;
+}
+declare function createSubscriptSlice(elements: ReadonlyArray<PyExpression>): PySubscriptSlice;
+//#endregion
+//#region src/py-compiler/nodes/expressions/tuple.d.ts
+interface PyTupleExpression extends PyNodeBase {
+  elements: ReadonlyArray<PyExpression>;
+  kind: PyNodeKind.TupleExpression;
+}
+declare function createTupleExpression(elements: ReadonlyArray<PyExpression>): PyTupleExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/yield.d.ts
+interface PyYieldExpression extends PyNodeBase {
+  kind: PyNodeKind.YieldExpression;
+  value?: PyExpression;
+}
+declare function createYieldExpression(value?: PyExpression): PyYieldExpression;
+//#endregion
+//#region src/py-compiler/nodes/expressions/yield-from.d.ts
+interface PyYieldFromExpression extends PyNodeBase {
+  expression: PyExpression;
+  kind: PyNodeKind.YieldFromExpression;
+}
+declare function createYieldFromExpression(expression: PyExpression): PyYieldFromExpression;
+//#endregion
+//#region src/py-compiler/nodes/expression.d.ts
+type PyExpression = PyAsyncExpression | PyAwaitExpression | PyBinaryExpression | PyCallExpression | PyComprehension | PyDictExpression | PyFStringExpression | PyGeneratorExpression | PyIdentifier | PyKeywordArgument | PyLambdaExpression | PyListExpression | PyLiteral | PyMemberExpression | PyRStringExpression | PySetExpression | PySubscriptExpression | PySubscriptSlice | PyTupleExpression | PyYieldExpression | PyYieldFromExpression;
+//#endregion
+//#region src/py-compiler/printer.d.ts
+type QuoteStyle = 'single' | 'double';
+type QuoteFallback = 'avoid-escape' | 'escape';
+interface PyPrinterOptions {
+  /**
+   * Number of spaces per indentation level.
+   *
+   * @default 4
+   */
+  indentSize?: number;
+  /**
+   * How to handle strings that contain the preferred quote character.
+   * - `'avoid-escape'`: switch to the alternative quote style to avoid
+   *   escaping, unless the string contains both quote characters
+   * - `'escape'`: always use the preferred quote style, escaping conflicts
+   *   with a backslash
+   *
+   * @default 'avoid-escape'
+   */
+  quoteConflict?: QuoteFallback;
+  /**
+   * Preferred string quote character.
+   *
+   * @default 'double'
+   */
+  quoteStyle?: QuoteStyle;
+}
+declare function createPrinter(options?: PyPrinterOptions): {
+  printFile: (node: PyNode) => string;
+};
+declare function printAst(node: PyNode): string;
+//#endregion
+//#region src/py-compiler/index.d.ts
+declare namespace py {
+  type Node = PyNode;
+  type NodeBase = PyNodeBase;
+  type NodeKind = PyNodeKind;
+  type Expression = PyExpression;
+  type Statement = PyStatement;
+  type SourceFile = PySourceFile;
+  type Comment = PyComment;
+  type ClassDeclaration = PyClassDeclaration;
+  type FunctionDeclaration = PyFunctionDeclaration;
+  type FunctionParameter = PyFunctionParameter;
+  type Assignment = PyAssignment;
+  type AugmentedAssignment = PyAugmentedAssignment;
+  type AugmentedOperator = PyAugmentedOperator;
+  type Block = PyBlock;
+  type BreakStatement = PyBreakStatement;
+  type ContinueStatement = PyContinueStatement;
+  type EmptyStatement = PyEmptyStatement;
+  type ExceptClause = PyExceptClause;
+  type ExpressionStatement = PyExpressionStatement;
+  type ForStatement = PyForStatement;
+  type IfStatement = PyIfStatement;
+  type ImportStatement = PyImportStatement;
+  type RaiseStatement = PyRaiseStatement;
+  type ReturnStatement = PyReturnStatement;
+  type TryStatement = PyTryStatement;
+  type WhileStatement = PyWhileStatement;
+  type WithItem = PyWithItem;
+  type WithStatement = PyWithStatement;
+  type AsyncExpression = PyAsyncExpression;
+  type AwaitExpression = PyAwaitExpression;
+  type BinaryExpression = PyBinaryExpression;
+  type BinaryOperator = PyBinaryOperator;
+  type CallExpression = PyCallExpression;
+  type DictExpression = PyDictExpression;
+  type FStringExpression = PyFStringExpression;
+  type GeneratorExpression = PyGeneratorExpression;
+  type Identifier = PyIdentifier;
+  type KeywordArgument = PyKeywordArgument;
+  type LambdaExpression = PyLambdaExpression;
+  type ListExpression = PyListExpression;
+  type Literal = PyLiteral;
+  type MemberExpression = PyMemberExpression;
+  type RStringExpression = PyRStringExpression;
+  type SetExpression = PySetExpression;
+  type SubscriptExpression = PySubscriptExpression;
+  type SubscriptSlice = PySubscriptSlice;
+  type TupleExpression = PyTupleExpression;
+  type YieldExpression = PyYieldExpression;
+  type YieldFromExpression = PyYieldFromExpression;
+  type Comprehension = PyComprehension;
+  type ComprehensionNode = PyComprehensionNode;
+  type DictComprehension = PyDictComprehension;
+  type ListComprehension = PyListComprehension;
+  type SetComprehension = PySetComprehension;
+  type PrinterOptions = PyPrinterOptions;
+  type LiteralValue = PyLiteralValue;
+}
+declare const py: {
+  readonly PyNodeKind: typeof PyNodeKind;
+  readonly createPrinter: typeof createPrinter;
+  readonly factory: {
+    createAssignment: typeof createAssignment;
+    createAsyncExpression: typeof createAsyncExpression;
+    createAugmentedAssignment: typeof createAugmentedAssignment;
+    createAwaitExpression: typeof createAwaitExpression;
+    createBinaryExpression: typeof createBinaryExpression;
+    createBlock: typeof createBlock;
+    createBreakStatement: typeof createBreakStatement;
+    createCallExpression: typeof createCallExpression;
+    createClassDeclaration: typeof createClassDeclaration;
+    createComment: typeof createComment;
+    createContinueStatement: typeof createContinueStatement;
+    createDictComprehension: typeof createDictComprehension;
+    createDictExpression: typeof createDictExpression;
+    createEmptyStatement: typeof createEmptyStatement;
+    createExceptClause: typeof createExceptClause;
+    createExpressionStatement: typeof createExpressionStatement;
+    createFStringExpression: typeof createFStringExpression;
+    createForStatement: typeof createForStatement;
+    createFunctionDeclaration: typeof createFunctionDeclaration;
+    createFunctionParameter: typeof createFunctionParameter;
+    createGeneratorExpression: typeof createGeneratorExpression;
+    createIdentifier: typeof createIdentifier;
+    createIfStatement: typeof createIfStatement;
+    createImportStatement: typeof createImportStatement;
+    createKeywordArgument: typeof createKeywordArgument;
+    createLambdaExpression: typeof createLambdaExpression;
+    createListComprehension: typeof createListComprehension;
+    createListExpression: typeof createListExpression;
+    createLiteral: typeof createLiteral;
+    createMemberExpression: typeof createMemberExpression;
+    createRStringExpression: typeof createRStringExpression;
+    createRaiseStatement: typeof createRaiseStatement;
+    createReturnStatement: typeof createReturnStatement;
+    createSetComprehension: typeof createSetComprehension;
+    createSetExpression: typeof createSetExpression;
+    createSourceFile: typeof createSourceFile;
+    createSubscriptExpression: typeof createSubscriptExpression;
+    createSubscriptSlice: typeof createSubscriptSlice;
+    createTryStatement: typeof createTryStatement;
+    createTupleExpression: typeof createTupleExpression;
+    createWhileStatement: typeof createWhileStatement;
+    createWithItem: typeof createWithItem;
+    createWithStatement: typeof createWithStatement;
+    createYieldExpression: typeof createYieldExpression;
+    createYieldFromExpression: typeof createYieldFromExpression;
+  };
+  readonly printAst: typeof printAst;
+};
+//#endregion
+//#region src/py-dsl/mixins/types.d.ts
+type BaseCtor<T extends py.Node> = abstract new (...args: Array<any>) => PyDsl<T>;
+type DropFirst<T extends Array<any>> = T extends [any, ...infer Rest] ? Rest : never;
+type MixinCtor<T extends BaseCtor<any>, K> = abstract new (...args: Array<any>) => InstanceType<T> & K;
+//#endregion
+//#region src/py-dsl/expr/attr.d.ts
+type AttrLeft = NodeName$1 | MaybePyDsl<py.Expression>;
+type AttrCtor = (left: AttrLeft, right: NodeName$1) => AttrPyDsl;
+declare const Mixed$36: MixinCtor<abstract new () => PyDsl<PyMemberExpression, "python">, ExprMethods>;
+declare class AttrPyDsl extends Mixed$36 {
+  readonly '~dsl' = "AttrPyDsl";
+  protected left: Ref<AttrLeft>;
+  constructor(left: AttrLeft, right: NodeName$1);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  toAst(): PyMemberExpression;
+  $validate(): asserts this is this & {
+    left: MaybePyDsl<py.Expression>;
+  };
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/expr/binary.d.ts
+type BinaryCtor = (left: MaybePyDsl<py.Expression>, op: PyBinaryOperator, right: MaybePyDsl<py.Expression>) => BinaryPyDsl;
+declare const Mixed$35: abstract new () => PyDsl<PyBinaryExpression, "python">;
+declare class BinaryPyDsl extends Mixed$35 {
+  readonly '~dsl' = "BinaryPyDsl";
+  protected _left?: Ref<MaybePyDsl<py.Expression>>;
+  protected _op?: PyBinaryOperator;
+  protected _right?: Ref<MaybePyDsl<py.Expression>>;
+  constructor(left: MaybePyDsl<py.Expression>, op: PyBinaryOperator, right: MaybePyDsl<py.Expression>);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  and(right: MaybePyDsl<py.Expression>): this;
+  div(right: MaybePyDsl<py.Expression>): this;
+  eq(right: MaybePyDsl<py.Expression>): this;
+  floordiv(right: MaybePyDsl<py.Expression>): this;
+  gt(right: MaybePyDsl<py.Expression>): this;
+  gte(right: MaybePyDsl<py.Expression>): this;
+  in_(right: MaybePyDsl<py.Expression>): this;
+  is(right: MaybePyDsl<py.Expression>): this;
+  isNot(right: MaybePyDsl<py.Expression>): this;
+  lt(right: MaybePyDsl<py.Expression>): this;
+  lte(right: MaybePyDsl<py.Expression>): this;
+  minus(right: MaybePyDsl<py.Expression>): this;
+  mod(right: MaybePyDsl<py.Expression>): this;
+  neq(right: MaybePyDsl<py.Expression>): this;
+  notIn(right: MaybePyDsl<py.Expression>): this;
+  or(right: MaybePyDsl<py.Expression>): this;
+  plus(right: MaybePyDsl<py.Expression>): this;
+  pow(right: MaybePyDsl<py.Expression>): this;
+  times(right: MaybePyDsl<py.Expression>): this;
+  toAst(): PyBinaryExpression;
+  $validate(): asserts this is this & {
+    _left: MaybePyDsl<py.Expression>;
+    _op: PyBinaryOperator;
+    _right: MaybePyDsl<py.Expression>;
+  };
+  private missingRequiredCalls;
+  private opAndExpr;
+}
+//#endregion
+//#region src/py-dsl/expr/expr.d.ts
+type ExprId = NodeName$1 | MaybePyDsl<py.Expression>;
+type ExprCtor = (id: ExprId) => ExprPyDsl;
+declare const Mixed$34: MixinCtor<abstract new () => PyDsl<PyExpression, "python">, ExprMethods>;
+declare class ExprPyDsl extends Mixed$34 {
+  readonly '~dsl' = "ExprPyDsl";
+  protected _exprInput: Ref<ExprId>;
+  constructor(id: ExprId);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): any;
+}
+//#endregion
+//#region src/py-dsl/mixins/layout.d.ts
+interface LayoutMethods extends Node$1 {
+  /** Computes whether output should be multiline based on layout setting and element count. */
+  $multiline(count: number): boolean;
+  /** Sets automatic line output with optional threshold (default: 3). */
+  auto(threshold?: number): this;
+  /** Sets single line output. */
+  inline(): this;
+  /** Sets multi line output. */
+  pretty(): this;
+}
+//#endregion
+//#region src/py-dsl/expr/subscript.d.ts
+type SubscriptExpr = NodeName$1 | MaybePyDsl<py.Expression>;
+type SubscriptCtor = (value: SubscriptExpr, ...slices: Array<SubscriptExpr>) => SubscriptPyDsl;
+declare const Mixed$33: MixinCtor<abstract new () => PyDsl<PySubscriptExpression, "python">, LayoutMethods>;
+declare class SubscriptPyDsl extends Mixed$33 {
+  readonly '~dsl' = "SubscriptPyDsl";
+  protected _slices: Array<Ref<SubscriptExpr>>;
+  protected _value: Ref<SubscriptExpr>;
+  constructor(value: SubscriptExpr, ...slices: Array<SubscriptExpr>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PySubscriptExpression;
+}
+//#endregion
+//#region src/py-dsl/expr/tuple.d.ts
+type TupleElement = NodeName$1 | MaybePyDsl<py.Expression>;
+type TupleCtor = (...elements: Array<TupleElement>) => TuplePyDsl;
+declare const Mixed$32: MixinCtor<abstract new () => PyDsl<PyTupleExpression, "python">, LayoutMethods>;
+declare class TuplePyDsl extends Mixed$32 {
+  readonly '~dsl' = "TuplePyDsl";
+  protected _elements: Array<Ref<TupleElement>>;
+  constructor(...elements: Array<TupleElement>);
+  analyze(ctx: AnalysisContext): void;
+  element(expr: TupleElement): this;
+  elements(...exprs: ReadonlyArray<TupleElement>): this;
+  toAst(): PyTupleExpression;
+}
+//#endregion
+//#region src/py-dsl/stmt/return.d.ts
+type ReturnExpr = NodeName$1 | MaybePyDsl<py.Expression>;
+type ReturnCtor = (expr?: ReturnExpr) => ReturnPyDsl;
+declare const Mixed$31: abstract new () => PyDsl<PyReturnStatement, "python">;
+declare class ReturnPyDsl extends Mixed$31 {
+  readonly '~dsl' = "ReturnPyDsl";
+  protected _returnExpr?: Ref<ReturnExpr>;
+  constructor(expr?: ReturnExpr);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyReturnStatement;
+}
+//#endregion
+//#region src/py-dsl/utils/factories.d.ts
+type Ctor = (...args: Array<any>) => any;
+type Factory<T extends Ctor> = {
+  (...args: Parameters<T>): ReturnType<T>; /** Sets the implementation of this factory. */
+  set(fn: T): void;
+};
+declare const f: {
+  /** Factory for creating property access expressions (e.g., `obj.foo`). */attr: Factory<AttrCtor>; /** Factory for creating binary expressions (e.g., `a + b`). */
+  binary: Factory<BinaryCtor>; /** Factory for creating function or method call expressions (e.g., `fn(arg)`). */
+  call: Factory<CallCtor>; /** Factory for creating expression nodes. */
+  expr: Factory<ExprCtor>; /** Factory for creating return statements. */
+  return: Factory<ReturnCtor>; /** Factory for creating slice expressions. */
+  slice: Factory<SubscriptCtor>; /** Factory for creating tuple expressions. */
+  tuple: Factory<TupleCtor>;
+};
+//#endregion
+//#region src/py-dsl/mixins/expr.d.ts
+interface ExprMethods extends Node$1 {
+  /** Accesses a property on the current expression (e.g., `this.foo`). */
+  attr(...args: DropFirst<Parameters<typeof f.attr>>): ReturnType<typeof f.attr>;
+  /** Calls the current expression (e.g., `fn(arg1, arg2)`). */
+  call(...args: DropFirst<Parameters<typeof f.call>>): ReturnType<typeof f.call>;
+  /** Produces a `return` statement returning the current expression. */
+  return(): ReturnType<typeof f.return>;
+  /** Produces a subscript/slice expression (e.g., `expr[args]`). */
+  slice(...args: DropFirst<Parameters<typeof f.slice>>): ReturnType<typeof f.slice>;
+}
+//#endregion
+//#region src/py-dsl/mixins/args.d.ts
+type Arg = NodeName$1 | MaybePyDsl<py.Expression>;
+interface ArgsMethods extends Node$1 {
+  /** Renders the arguments into an array of `Expression`s. */
+  $args(): ReadonlyArray<py.Expression>;
+  /** Adds a single expression argument. */
+  arg(arg: Arg | undefined): this;
+  /** Adds one or more expression arguments. */
+  args(...args: ReadonlyArray<Arg | undefined>): this;
+}
+//#endregion
+//#region src/py-dsl/expr/call.d.ts
+type CallArgs = ReadonlyArray<CallCallee | undefined>;
+type CallCallee = NodeName$1 | MaybePyDsl<py.Expression>;
+type CallCtor = (callee: CallCallee, ...args: CallArgs) => CallPyDsl;
+declare const Mixed$30: MixinCtor<MixinCtor<abstract new () => PyDsl<PyCallExpression, "python">, ExprMethods>, ArgsMethods>;
+declare class CallPyDsl extends Mixed$30 {
+  readonly '~dsl' = "CallPyDsl";
+  protected _callee: Ref<CallCallee>;
+  constructor(callee: CallCallee, ...args: CallArgs);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  toAst(): PyCallExpression;
+  $validate(): asserts this is this & {
+    _callee: MaybePyDsl<py.Expression>;
+  };
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/utils/context.d.ts
+type NodeChain = ReadonlyArray<PyDsl>;
+interface AccessOptions {
+  /** The access context. */
+  context?: 'example';
+  /** Enable debug mode. */
+  debug?: boolean;
+  /** Transform function for each node in the access chain. */
+  transform?: (node: PyDsl, index: number, chain: NodeChain) => PyDsl;
+}
+interface ExampleOptions {
+  /** Import kind for the root node. */
+  importKind?: BindingKind;
+  /** Import name for the root node. */
+  importName?: string;
+  /** Setup to run before calling the example. */
+  importSetup?: MaybeFunc<(ctx: DollarPyDsl & {
+    /** The imported expression. */node: PyDsl<py.Expression>;
+  }) => PyDsl<py.Expression>>;
+  /** Module to import from. */
+  moduleName?: string;
+  /** Example request payload. */
+  payload?: MaybeFunc<(ctx: DollarPyDsl) => CallArgs | CallArgs[number]>;
+  /** Variable name for setup node. */
+  setupName?: string;
+}
+/**
+ * Fold a structural chain to an access chain by removing
+ * non-accessor nodes.
+ */
+declare class PyDslContext {}
+//#endregion
+//#region src/py-dsl/base.d.ts
+declare abstract class PyDsl<T extends py.Node = py.Node, L extends Language = 'python'> implements Node$1<T, L> {
+  analyze(_: AnalysisContext): void;
+  clone(): this;
+  exported?: boolean;
+  file?: File;
+  get name(): Node$1['name'];
+  readonly nameSanitizer?: NodeNameSanitizer;
+  language: L;
+  meta: Required<ProjectMeta>[L];
+  parent?: Node$1;
+  root: boolean;
+  scope?: NodeScope;
+  structuralChildren?: Map<PyDsl, NodeRelationship>;
+  structuralParents?: Map<PyDsl, NodeRelationship>;
+  symbol?: Symbol;
+  toAst(): T;
+  readonly '~brand': any;
+  /** Branding property to identify the DSL class at runtime. */
+  abstract readonly '~dsl': AnyString;
+  /** Conditionally applies a callback to this builder. */
+  $if<T extends PyDsl, V, R extends PyDsl = T>(this: T, value: V, ifTrue: (self: T, v: Exclude<V, false | null | undefined>) => R | void, ifFalse?: (self: T, v: Extract<V, false | null | undefined>) => R | void): R | T;
+  $if<T extends PyDsl, V, R extends PyDsl = T>(this: T, value: V, ifTrue: (v: Exclude<V, false | null | undefined>) => R | void, ifFalse?: (v: Extract<V, false | null | undefined>) => R | void): R | T;
+  $if<T extends PyDsl, V, R extends PyDsl = T>(this: T, value: V, ifTrue: () => R | void, ifFalse?: () => R | void): R | T;
+  /** Access patterns for this node. */
+  toAccessNode?(node: this, options: AccessOptions, ctx: {
+    /** The full chain. */chain: ReadonlyArray<PyDsl>; /** Position in the chain (0 = root). */
+    index: number; /** Is this the leaf node? */
+    isLeaf: boolean; /** Is this the root node? */
+    isRoot: boolean; /** Total length of the chain. */
+    length: number;
+  }): PyDsl | undefined;
+  protected $maybeId<T extends string | py.Expression>(expr: T): T extends string ? py.Identifier : T;
+  protected $name(name: Ref<NodeName$1>): string;
+  protected $node<I>(value: I): NodeOfMaybe<I>;
+  private _name?;
+  /** Unwraps nested nodes into raw Python AST. */
+  private unwrap;
+}
+type NodeOfMaybe<I> = undefined extends I ? NodeOf<NonNullable<FromRef<I>>> | undefined : NodeOf<FromRef<I>>;
+type NodeOf<I> = I extends ReadonlyArray<infer U> ? ReadonlyArray<U extends PyDsl<infer N> ? N : U> : I extends string ? py.Expression : I extends PyDsl<infer N> ? N : I extends py.Node ? I : never;
+type MaybePyDsl<T> = [T] extends [PyDsl<infer U>] ? U | PyDsl<U> : [T] extends [py.Node] ? T | PyDsl<T> : never;
+//#endregion
+//#region src/py-dsl/layout/doc.d.ts
+type DocMaybeLazy<T> = ((ctx: PyDslContext) => T) | T;
+type DocFn = (d: DocPyDsl) => void;
+type DocLines = DocMaybeLazy<MaybeArray<string>>;
+declare class DocPyDsl extends PyDsl<py.Comment> {
+  readonly '~dsl' = "DocPyDsl";
+  protected _lines: Array<DocLines>;
+  constructor(lines?: DocLines, fn?: DocFn);
+  analyze(ctx: AnalysisContext): void;
+  add(lines: DocLines): this;
+  resolve(): string | undefined;
+  toAst(): PyComment;
+}
+//#endregion
+//#region src/py-dsl/layout/hint.d.ts
+type HintMaybeLazy<T> = ((ctx: PyDslContext) => T) | T;
+type HintFn = (d: HintPyDsl) => void;
+type HintLines = HintMaybeLazy<MaybeArray<string>>;
+declare class HintPyDsl extends PyDsl<py.Comment> {
+  readonly '~dsl' = "HintPyDsl";
+  protected _lines: Array<HintLines>;
+  constructor(lines?: HintLines, fn?: HintFn);
+  analyze(ctx: AnalysisContext): void;
+  add(lines: HintLines): this;
+  apply<T extends py.Node>(node: T): T;
+  toAst(): PyComment;
+  private _resolveLines;
+}
+//#endregion
+//#region src/py-dsl/mixins/do.d.ts
+type DoExpr = MaybePyDsl<py.Expression | py.Statement>;
+interface DoMethods extends Node$1 {
+  /** Renders the collected `.do()` calls into an array of `py.Statement` nodes. */
+  $do(): ReadonlyArray<py.Statement>;
+  _do: Array<DoExpr>;
+  /** Adds one or more expressions/statements to the body. */
+  do(...items: ReadonlyArray<DoExpr>): this;
+}
+//#endregion
+//#region src/py-dsl/stmt/if.d.ts
+type IfCondition = string | MaybePyDsl<py.Expression>;
+declare const Mixed$29: MixinCtor<abstract new () => PyDsl<PyIfStatement, "python">, DoMethods>;
+declare class IfPyDsl extends Mixed$29 {
+  readonly '~dsl' = "IfPyDsl";
+  protected _condition?: IfCondition;
+  protected _else?: Array<DoExpr>;
+  constructor(condition?: IfCondition);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  condition(condition: IfCondition): this;
+  otherwise(...items: Array<DoExpr>): this;
+  toAst(): PyIfStatement;
+  $validate(): asserts this is this & {
+    _condition: IfCondition;
+  };
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/utils/r-string.d.ts
+declare class RString {
+  readonly value: string;
+  readonly '~brand': "RString";
+  constructor(value: string);
+}
+//#endregion
+//#region src/py-dsl/expr/kwarg.d.ts
+type KwargValue = string | number | boolean | null | RString | MaybePyDsl<py.Expression>;
+declare const Mixed$28: abstract new () => PyDsl<PyKeywordArgument, "python">;
+declare class KwargPyDsl extends Mixed$28 {
+  readonly '~dsl' = "KwargPyDsl";
+  protected _value: KwargValue;
+  constructor(name: NodeName$1, value: KwargValue);
+  get key(): string;
+  toAst(): PyKeywordArgument;
+  private $valueToNode;
+}
+//#endregion
+//#region src/py-dsl/utils/lazy.d.ts
+type LazyThunk<T extends py.Node> = (ctx: PyDslContext) => PyDsl<T>;
+declare class LazyPyDsl<T extends py.Node = py.Node> extends PyDsl<T> {
+  readonly '~dsl' = "LazyPyDsl";
+  private _thunk;
+  private _result?;
+  constructor(thunk: LazyThunk<T>);
+  analyze(ctx: AnalysisContext): void;
+  toResult(): PyDsl<T>;
+  toAst(): T;
+}
+//#endregion
+//#region src/py-dsl/decl/param.d.ts
+type ParamDefaultValue = NodeName$1 | py.Expression | undefined;
+type ParamFn = (p: ParamPyDsl) => void;
+type ParamName = NodeName$1 | ParamFn;
+type ParamType = NodeName$1 | PyDsl<py.Expression> | undefined;
+type ParamCtor = (name: ParamName, fn?: ParamFn) => ParamPyDsl;
+declare class ParamPyDsl extends PyDsl<py.FunctionParameter> {
+  readonly '~dsl' = "ParamPyDsl";
+  protected _defaultValue?: Ref<ParamDefaultValue>;
+  protected _type?: Ref<ParamType>;
+  constructor(name: ParamName, fn?: ParamFn);
+  analyze(ctx: AnalysisContext): void;
+  /** Sets the parameter default value. */
+  default(value: ParamDefaultValue): this;
+  get isValid(): boolean;
+  /** Sets the parameter type. */
+  type(type: ParamType): this;
+  toAst(): PyFunctionParameter;
+  $validate(): asserts this;
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/mixins/modifiers.d.ts
+type Modifiers = {
+  /**
+   * Checks if specified modifier is present.
+   *
+   * @param modifier - The modifier to check.
+   * @returns True if modifier is present, false otherwise.
+   */
+  hasModifier(modifier: Modifier): boolean;
+  modifiers: Array<py.Expression>;
+};
+type Modifier = 'async';
+interface AsyncMethods extends Modifiers {
+  /**
+   * Adds an `async` keyword modifier if condition is true.
+   *
+   * @param condition - Whether to add modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  async(condition?: boolean): this;
+}
+interface ExportMethods extends Modifiers {
+  /**
+   * Adds the `export` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  export(condition?: boolean): this;
+}
+//#endregion
+//#region src/py-dsl/mixins/doc.d.ts
+interface DocMethods extends Node$1 {
+  $docs(): string | undefined;
+  doc(lines?: DocLines, fn?: DocFn): this;
+}
+//#endregion
+//#region src/py-dsl/mixins/decorator.d.ts
+type DecoratorArg = MaybePyDsl<py.Expression>;
+type DecoratorName = NodeName$1 | MaybePyDsl<py.Expression>;
+interface DecoratorMethods extends Node {
+  $decorators(): ReadonlyArray<py.Expression>;
+  decorator(name: DecoratorName, ...args: ReadonlyArray<DecoratorArg>): this;
+}
+//#endregion
+//#region src/py-dsl/utils/name.d.ts
+declare function safeRuntimeName(name: string): string;
+declare function safeKeywordName(name: string): string;
+//#endregion
+//#region src/py-dsl/decl/class.d.ts
+type ClassBody = Array<PyDsl<py.Statement>>;
+declare const Mixed$27: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => PyDsl<PyClassDeclaration, "python">, LayoutMethods>, ExportMethods>, DocMethods>, DecoratorMethods>;
+declare class ClassPyDsl extends Mixed$27 {
+  readonly '~dsl' = "ClassPyDsl";
+  readonly nameSanitizer: typeof safeRuntimeName;
+  protected baseClasses: Array<Ref<NodeName$1 | SubscriptExpr>>;
+  protected body: ClassBody;
+  constructor(name: NodeName$1);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  /** Returns true if the class has any members. */
+  get hasBody(): boolean;
+  /** Adds one or more class members (fields, methods, etc.). */
+  do(...items: ClassBody): this;
+  /** Records base classes to extend from. */
+  extends(...baseClass: ReadonlyArray<NodeName$1 | SubscriptExpr>): this;
+  /** Inserts an empty line between members for formatting. */
+  newline(): this;
+  toAst(): PyClassDeclaration;
+  $validate(): asserts this;
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/decl/enum.d.ts
+type EnumMember = {
+  name: NodeName$1;
+  value: number | string | boolean;
+};
+declare const Mixed$26: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => PyDsl<PyClassDeclaration, "python">, LayoutMethods>, ExportMethods>, DocMethods>, DecoratorMethods>;
+declare class EnumPyDsl extends Mixed$26 {
+  readonly '~dsl' = "EnumPyDsl";
+  readonly nameSanitizer: typeof safeRuntimeName;
+  private _decision?;
+  private _members;
+  constructor(name: NodeName$1);
+  members(...members: ReadonlyArray<EnumMember>): this;
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  toAst(): PyClassDeclaration;
+  $validate(): asserts this;
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/mixins/value.d.ts
+type ValueExpr = NodeName$1 | MaybePyDsl<py.Expression>;
+interface ValueMethods extends Node$1 {
+  $value(): py.Expression | undefined;
+  /** Sets the initializer expression (e.g., `= expr`). */
+  assign(expr: ValueExpr): this;
+}
+//#endregion
+//#region src/py-dsl/decl/field.d.ts
+declare const Mixed$25: MixinCtor<abstract new () => PyDsl<PyAssignment, "python">, ValueMethods>;
+type FieldType = NodeName$1 | MaybePyDsl<py.Expression>;
+declare class FieldPyDsl extends Mixed$25 {
+  readonly '~dsl' = "FieldPyDsl";
+  readonly nameSanitizer: typeof safeKeywordName;
+  protected _type?: Ref<FieldType>;
+  constructor(name?: NodeName$1);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  /** Sets the type annotation for the field. */
+  type(type: FieldType): this;
+  toAst(): PyAssignment;
+  $validate(): asserts this;
+  protected $_type(): py.Expression | undefined;
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/mixins/returns.d.ts
+interface ReturnsMethods extends Node$1 {
+  $returns(): py.Expression | undefined;
+  returns(type: NodeName$1 | py.Expression): this;
+}
+//#endregion
+//#region src/py-dsl/mixins/param.d.ts
+interface ParamMethods extends Node$1 {
+  /** Renders the parameters into an array of `FunctionParameter`s. */
+  $params(): ReadonlyArray<py.FunctionParameter>;
+  /** Adds a parameter. */
+  param(...args: Parameters<ParamCtor>): this;
+  /** Adds multiple parameters. */
+  params(...params: ReadonlyArray<MaybePyDsl<py.FunctionParameter>>): this;
+}
+//#endregion
+//#region src/py-dsl/decl/func.d.ts
+declare const Mixed$24: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => PyDsl<PyFunctionDeclaration, "python">, ReturnsMethods>, ParamMethods>, LayoutMethods>, ExportMethods>, DoMethods>, DocMethods>, DecoratorMethods>, AsyncMethods>;
+declare class FuncPyDsl extends Mixed$24 {
+  readonly '~dsl' = "FuncPyDsl";
+  readonly nameSanitizer: typeof safeRuntimeName;
+  constructor(name: NodeName$1, fn?: (f: FuncPyDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  toAst(): PyFunctionDeclaration;
+  $validate(): asserts this;
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/decl/method.d.ts
+declare const Mixed$23: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => PyDsl<PyFunctionDeclaration, "python">, ReturnsMethods>, ParamMethods>, LayoutMethods>, DoMethods>, DocMethods>, DecoratorMethods>, AsyncMethods>;
+declare class MethodPyDsl extends Mixed$23 {
+  readonly '~dsl' = "MethodPyDsl";
+  readonly nameSanitizer: typeof safeKeywordName;
+  constructor(name: NodeName$1, fn?: (f: MethodPyDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  toAst(): PyFunctionDeclaration;
+  $validate(): asserts this;
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/expr/dict.d.ts
+declare const Mixed$22: MixinCtor<abstract new () => PyDsl<PyDictExpression, "python">, LayoutMethods>;
+declare class DictPyDsl extends Mixed$22 {
+  readonly '~dsl' = "DictPyDsl";
+  protected _entries: Array<{
+    key: MaybePyDsl<py.Expression>;
+    value: MaybePyDsl<py.Expression>;
+  }>;
+  constructor(...entries: Array<{
+    key: MaybePyDsl<py.Expression>;
+    value: MaybePyDsl<py.Expression>;
+  }>);
+  analyze(ctx: AnalysisContext): void;
+  entry(key: MaybePyDsl<py.Expression>, value: MaybePyDsl<py.Expression>): this;
+  entries(...entries: ReadonlyArray<{
+    key: MaybePyDsl<py.Expression>;
+    value: MaybePyDsl<py.Expression>;
+  }>): this;
+  toAst(): PyDictExpression;
+}
+//#endregion
+//#region src/py-dsl/expr/identifier.d.ts
+declare const Mixed$21: abstract new () => PyDsl<PyIdentifier, "python">;
+declare class IdPyDsl extends Mixed$21 {
+  readonly '~dsl' = "IdPyDsl";
+  constructor(name: NodeName$1);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyIdentifier;
+}
+//#endregion
+//#region src/py-dsl/expr/list.d.ts
+declare const Mixed$20: MixinCtor<abstract new () => PyDsl<PyListExpression, "python">, LayoutMethods>;
+declare class ListPyDsl extends Mixed$20 {
+  readonly '~dsl' = "ListPyDsl";
+  protected _elements: Array<MaybePyDsl<py.Expression>>;
+  constructor(...elements: Array<MaybePyDsl<py.Expression>>);
+  analyze(ctx: AnalysisContext): void;
+  element(expr: MaybePyDsl<py.Expression>): this;
+  elements(...exprs: ReadonlyArray<MaybePyDsl<py.Expression>>): this;
+  toAst(): PyListExpression;
+}
+//#endregion
+//#region src/py-dsl/expr/literal.d.ts
+declare const Mixed$19: abstract new () => PyDsl<PyLiteral, "python">;
+declare class LiteralPyDsl extends Mixed$19 {
+  readonly '~dsl' = "LiteralPyDsl";
+  protected value: py.LiteralValue;
+  constructor(value: py.LiteralValue);
+  analyze(_ctx: AnalysisContext): void;
+  toAst(): PyLiteral;
+}
+//#endregion
+//#region src/py-dsl/expr/set.d.ts
+declare const Mixed$18: MixinCtor<abstract new () => PyDsl<PySetExpression, "python">, LayoutMethods>;
+declare class SetPyDsl extends Mixed$18 {
+  readonly '~dsl' = "SetPyDsl";
+  protected _elements: Array<MaybePyDsl<py.Expression>>;
+  constructor(...elements: Array<MaybePyDsl<py.Expression>>);
+  analyze(ctx: AnalysisContext): void;
+  element(expr: MaybePyDsl<py.Expression>): this;
+  elements(...exprs: ReadonlyArray<MaybePyDsl<py.Expression>>): this;
+  toAst(): PySetExpression;
+}
+//#endregion
+//#region src/py-dsl/layout/newline.d.ts
+declare class NewlinePyDsl extends PyDsl<py.EmptyStatement> {
+  readonly '~dsl' = "NewlinePyDsl";
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyEmptyStatement;
+}
+//#endregion
+//#region src/py-dsl/stmt/block.d.ts
+declare const Mixed$17: MixinCtor<MixinCtor<abstract new () => PyDsl<PyBlock, "python">, LayoutMethods>, DoMethods>;
+declare class BlockPyDsl extends Mixed$17 {
+  readonly '~dsl' = "BlockPyDsl";
+  constructor(...items: Array<DoExpr>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyBlock;
+}
+//#endregion
+//#region src/py-dsl/stmt/break.d.ts
+declare const Mixed$16: abstract new () => PyDsl<PyBreakStatement, "python">;
+declare class BreakPyDsl extends Mixed$16 {
+  readonly '~dsl' = "BreakPyDsl";
+  analyze(_ctx: AnalysisContext): void;
+  toAst(): PyBreakStatement;
+}
+//#endregion
+//#region src/py-dsl/stmt/continue.d.ts
+declare const Mixed$15: abstract new () => PyDsl<PyContinueStatement, "python">;
+declare class ContinuePyDsl extends Mixed$15 {
+  readonly '~dsl' = "ContinuePyDsl";
+  analyze(_ctx: AnalysisContext): void;
+  toAst(): PyContinueStatement;
+}
+//#endregion
+//#region src/py-dsl/stmt/for.d.ts
+declare const Mixed$14: abstract new () => PyDsl<PyForStatement, "python">;
+declare class ForPyDsl extends Mixed$14 {
+  readonly '~dsl' = "ForPyDsl";
+  protected _body?: Array<DoExpr>;
+  protected _else?: Array<DoExpr>;
+  protected _iterable?: MaybePyDsl<py.Expression>;
+  protected _target?: MaybePyDsl<py.Expression>;
+  constructor(target: MaybePyDsl<py.Expression>, iterable: MaybePyDsl<py.Expression>, ...body: Array<DoExpr>);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  body(...items: Array<DoExpr>): this;
+  else(...items: Array<DoExpr>): this;
+  toAst(): PyForStatement;
+  $validate(): asserts this is this & {
+    _body: Array<DoExpr>;
+    _iterable: MaybePyDsl<py.Expression>;
+    _target: MaybePyDsl<py.Expression>;
+  };
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/stmt/import.d.ts
+type ImportName = {
+  alias?: string;
+  name: string;
+};
+declare const Mixed$13: abstract new () => PyDsl<PyImportStatement, "python">;
+declare class ImportPyDsl extends Mixed$13 {
+  readonly '~dsl' = "ImportPyDsl";
+  protected isFrom: boolean;
+  protected module: string;
+  protected names?: ReadonlyArray<ImportName>;
+  constructor(module: string);
+  constructor(module: string, isFrom: boolean);
+  constructor(module: string, names: ReadonlyArray<ImportName>, isFrom: boolean);
+  static from(module: string, names?: ReadonlyArray<ImportName>): ImportPyDsl;
+  static direct(module: string): ImportPyDsl;
+  analyze(_ctx: AnalysisContext): void;
+  toAst(): PyImportStatement;
+}
+//#endregion
+//#region src/py-dsl/stmt/raise.d.ts
+declare const Mixed$12: abstract new () => PyDsl<PyRaiseStatement, "python">;
+declare class RaisePyDsl extends Mixed$12 {
+  readonly '~dsl' = "RaisePyDsl";
+  protected _error?: string | MaybePyDsl<py.Expression>;
+  constructor(error?: string | MaybePyDsl<py.Expression>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyRaiseStatement;
+}
+//#endregion
+//#region src/py-dsl/stmt/stmt.d.ts
+declare const Mixed$11: abstract new () => PyDsl<PyStatement, "python">;
+declare class StmtPyDsl extends Mixed$11 {
+  readonly '~dsl' = "StmtPyDsl";
+  protected _inner: py.Expression | py.Statement | PyDsl<any>;
+  constructor(inner: py.Expression | py.Statement | PyDsl<any>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyStatement;
+}
+//#endregion
+//#region src/py-dsl/stmt/try.d.ts
+declare const Mixed$10: abstract new () => PyDsl<PyTryStatement, "python">;
+type ExceptType = string | MaybePyDsl<py.Expression>;
+interface ExceptEntry {
+  body: Array<DoExpr>;
+  name?: Ref<NodeName$1>;
+  types: Array<ExceptType>;
+}
+declare class TryPyDsl extends Mixed$10 {
+  readonly '~dsl' = "TryPyDsl";
+  /**
+   * Ordered list of except clauses.  We also keep a lookup map
+   * (`_exceptIndex`) keyed by the normalised type key so that
+   * repeated `.except()` calls with the same type set merge their
+   * body statements instead of creating duplicate clauses.
+   */
+  protected _excepts: Array<ExceptEntry>;
+  protected _exceptIndex: Map<string, number>;
+  protected _finally?: Array<DoExpr>;
+  protected _try?: Array<DoExpr>;
+  constructor(...tryBlock: Array<DoExpr>);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  /**
+   * Add (or merge into) an except clause.
+   *
+   * ```ts
+   * $.try(...)
+   *   .except('ValueError', 'e', body1, body2)     // except ValueError as e:
+   *   .except(['TypeError', 'KeyError'], 'e', ...) // except (TypeError, KeyError) as e:
+   *   .except('ValueError', moreBody)              // merges into first clause
+   * ```
+   *
+   * @param types  Single exception type or array of types.
+   * @param nameOrBody  Either the `as` variable name (`NodeName`) or the
+   *   first body expression. If it looks like a `NodeName` (string that
+   *   is a valid Python identifier and is *not* a DSL node), it is treated
+   *   as the name; pass body items after it.
+   * @param body   Remaining body statements.
+   */
+  except(types: MaybeArray<ExceptType>, nameOrBody?: NodeName$1 | DoExpr, ...body: Array<DoExpr>): this;
+  /** Add a bare `except:` clause (catches everything). */
+  exceptAll(...body: Array<DoExpr>): this;
+  finally(...items: Array<DoExpr>): this;
+  try(...items: Array<DoExpr>): this;
+  toAst(): PyTryStatement;
+  $validate(): asserts this is this & {
+    _try: Array<DoExpr>;
+  };
+  private missingRequiredCalls;
+  /**
+   * Heuristic: a value is a `NodeName` (intended as the `as` variable)
+   * if it is a plain string matching a Python identifier pattern, or a
+   * Symbol.
+   */
+  private _isNodeName;
+}
+//#endregion
+//#region src/py-dsl/stmt/var.d.ts
+declare const Mixed$9: MixinCtor<abstract new () => PyDsl<PyAssignment, "python">, ValueMethods>;
+type VarType = NodeName$1 | MaybePyDsl<py.Expression>;
+declare class VarPyDsl extends Mixed$9 {
+  readonly '~dsl' = "VarPyDsl";
+  readonly nameSanitizer: typeof safeRuntimeName;
+  protected _type?: Ref<VarType>;
+  constructor(name?: NodeName$1);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  /** Sets the type annotation for the variable. */
+  type(type: VarType): this;
+  toAst(): PyAssignment;
+  $validate(): asserts this;
+  protected $_type(): py.Expression | undefined;
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/stmt/while.d.ts
+declare const Mixed$8: abstract new () => PyDsl<PyWhileStatement, "python">;
+declare class WhilePyDsl extends Mixed$8 {
+  readonly '~dsl' = "WhilePyDsl";
+  protected _body?: Array<DoExpr>;
+  protected _condition?: MaybePyDsl<py.Expression>;
+  protected _else?: Array<DoExpr>;
+  constructor(condition: MaybePyDsl<py.Expression>, ...body: Array<DoExpr>);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  body(...items: Array<DoExpr>): this;
+  else(...items: Array<DoExpr>): this;
+  toAst(): PyWhileStatement;
+  $validate(): asserts this is this & {
+    _body: Array<DoExpr>;
+    _condition: MaybePyDsl<py.Expression>;
+  };
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/stmt/with.d.ts
+declare const Mixed$7: abstract new () => PyDsl<PyWithStatement, "python">;
+type WithItemInput = MaybePyDsl<py.Expression> | {
+  alias?: MaybePyDsl<py.Expression>;
+  context: MaybePyDsl<py.Expression>;
+};
+declare class WithPyDsl extends Mixed$7 {
+  readonly '~dsl' = "WithPyDsl";
+  protected _body?: Array<DoExpr>;
+  protected _items: Array<WithItemInput>;
+  protected _modifier?: MaybePyDsl<py.Expression>;
+  constructor(...items: Array<WithItemInput>);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  body(...items: Array<DoExpr>): this;
+  item(item: WithItemInput): this;
+  modifier(expr: MaybePyDsl<py.Expression>): this;
+  async(): this;
+  toAst(): PyWithStatement;
+  $validate(): asserts this is this & {
+    _body: Array<DoExpr>;
+  };
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/py-dsl/type/or.d.ts
+declare const Mixed$6: abstract new () => PyDsl<PyExpression, "python">;
+type Type$1 = NodeName$1 | MaybePyDsl<py.Expression>;
+declare class TypeOrPyDsl extends Mixed$6 {
+  readonly '~dsl' = "TypeOrPyDsl";
+  scope: NodeScope;
+  protected _types: Array<Ref<Type$1>>;
+  private _decision?;
+  constructor(...nodes: Array<Type$1>);
+  analyze(ctx: AnalysisContext): void;
+  types(...nodes: Array<Type$1>): this;
+  toAst(): any;
+  $validate(): asserts this;
+  private $flatten;
+  private $flattenRefs;
+}
+//#endregion
+//#region src/py-dsl/type/tuple.d.ts
+declare const Mixed$5: abstract new () => PyDsl<PyExpression, "python">;
+type Type = NodeName$1 | MaybePyDsl<py.Expression>;
+declare class TypeTuplePyDsl extends Mixed$5 {
+  readonly '~dsl' = "TypeTuplePyDsl";
+  scope: NodeScope;
+  protected _items: Array<Ref<Type>>;
+  private _decision?;
+  constructor(...nodes: Array<Type>);
+  analyze(ctx: AnalysisContext): void;
+  items(...nodes: Array<Type>): this;
+  toAst(): any;
+  $validate(): asserts this;
+  private $flatten;
+  private $flattenRefs;
+}
+//#endregion
+//#region src/py-dsl/index.d.ts
+declare const $$1: ((id: any) => ExprPyDsl) & {
+  /** Creates an array literal expression (e.g., `[1, 2, 3]`). */
+  /** Creates an `as` type assertion expression (e.g., `value as Type`). */
+  /** Creates a property access expression (e.g., `obj.foo`). */
+  attr: (left: any, right: NodeName$1) => AttrPyDsl;
+  /** Creates an await expression (e.g., `await promise`). */
+  /** Creates a binary expression (e.g., `a + b`). */
+  binary: (left: PyExpression | PyDsl<PyExpression, "python">, op: PyBinaryOperator, right: PyExpression | PyDsl<PyExpression, "python">) => BinaryPyDsl; /** Creates a statement block. */
+  block: (...args: ConstructorParameters<typeof BlockPyDsl>) => BlockPyDsl; /** Creates a break statement. */
+  break: () => BreakPyDsl; /** Creates a function or method call expression (e.g., `fn(arg)`). */
+  call: (callee: any, ...args: any[]) => CallPyDsl; /** Creates a class declaration or expression. */
+  class: (name: NodeName$1) => ClassPyDsl; /** Creates a continue statement. */
+  continue: () => ContinuePyDsl;
+  /** Creates a decorator expression (e.g., `@decorator`). */
+  /** Creates a dictionary expression (e.g., `{ 'a': 1 }`). */
+  dict: (...args: ConstructorParameters<typeof DictPyDsl>) => DictPyDsl; /** Creates a Python docstring (`"""..."""`). */
+  doc: (lines?: DocLines | undefined, fn?: DocFn | undefined) => DocPyDsl; /** Creates an enum declaration. */
+  enum: (name: NodeName$1) => EnumPyDsl; /** Creates a general expression node. */
+  expr: (id: any) => ExprPyDsl; /** Creates a field declaration in a class body. */
+  field: (name?: any) => FieldPyDsl; /** Creates a for statement (e.g., `for x in items:`). */
+  for: (target: PyExpression | PyDsl<PyExpression, "python">, iterable: PyExpression | PyDsl<PyExpression, "python">, ...body: (PyExpression | PyStatement | PyDsl<PyExpression | PyStatement, "python">)[]) => ForPyDsl;
+  /** Converts a runtime value into a corresponding expression node. */
+  /** Creates a function declaration. */
+  func: {
+    (name: NodeName$1): FuncPyDsl;
+    (name: NodeName$1, fn: (f: FuncPyDsl) => void): FuncPyDsl;
+  };
+  /** Creates a getter method declaration. */
+  /** Creates a Python comment (`# ...`). */
+  hint: (lines?: HintLines | undefined, fn?: HintFn | undefined) => HintPyDsl; /** Creates an identifier (e.g., `foo`). */
+  id: (name: NodeName$1) => IdPyDsl; /** Creates an if statement. */
+  if: (condition?: IfCondition | undefined) => IfPyDsl; /** Creates an import statement. */
+  import: (module: string, names: readonly {
+    alias?: string;
+    name: string;
+  }[], isFrom: boolean) => ImportPyDsl;
+  /** Creates an initialization block or statement. */
+  /** Creates a keyword argument expression (e.g., `name=value`). */
+  kwarg: (name: NodeName$1, value: KwargValue) => KwargPyDsl; /** Creates a lazy, context-aware node with deferred evaluation. */
+  lazy: <T extends py.Node>(thunk: LazyThunk<T>) => LazyPyDsl<T>; /** Creates a list expression (e.g., `[1, 2, 3]`). */
+  list: (...args: ConstructorParameters<typeof ListPyDsl>) => ListPyDsl; /** Creates a literal value (e.g., string, number, boolean). */
+  literal: (value: PyLiteralValue) => LiteralPyDsl;
+  /** Creates an enum member declaration. */
+  /** Creates a method declaration in a class body. */
+  method: {
+    (name: NodeName$1): MethodPyDsl;
+    (name: NodeName$1, fn: (f: MethodPyDsl) => void): MethodPyDsl;
+  };
+  /** Creates a negation expression (`-x`). */
+  /** Creates a new expression (e.g., `new ClassName()`). */
+  /** Creates a newline (for formatting purposes). */
+  newline: () => NewlinePyDsl;
+  /** Creates a logical NOT expression (`!x`). */
+  /** Creates an object literal expression. */
+  /** Creates a parameter declaration for functions or methods. */
+  param: (name: any, fn?: ParamFn | undefined) => ParamPyDsl;
+  /** Creates a pattern for destructuring or matching. */
+  /** Creates a prefix unary expression (e.g., `-x`, `!x`, `~x`). */
+  /** Creates an object literal property (e.g., `{ foo: bar }`). */
+  /** Creates a raise statement. */
+  raise: (error?: string | PyExpression | PyDsl<PyExpression, "python"> | undefined) => RaisePyDsl;
+  /** Creates a regular expression literal (e.g., `/foo/gi`). */
+  /** Creates a return statement. */
+  return: (expr?: any) => ReturnPyDsl; /** Creates a set expression (e.g., `{1, 2, 3}`). */
+  set: (...args: ConstructorParameters<typeof SetPyDsl>) => SetPyDsl;
+  /** Creates a setter method declaration. */
+  /** Wraps an expression or statement-like value into a `StmtPyDsl`. */
+  stmt: (inner: PyExpression | PyStatement | PyDsl<any, "python">) => StmtPyDsl; /** Creates a subscript expression (e.g., `obj[index]` or `Type[Param]`). */
+  subscript: (value: any, ...slices: any[]) => SubscriptPyDsl;
+  /** Creates a template literal expression. */
+  /** Creates a ternary conditional expression (if ? then : else). */
+  /** Creates a syntax token (e.g., `?`, `readonly`, `+`, `-`). */
+  /** Creates a try/except/finally statement. */
+  try: (...args: ConstructorParameters<typeof TryPyDsl>) => TryPyDsl; /** Creates a tuple expression (e.g., `(1, 2, 3)`). */
+  tuple: (...args: ConstructorParameters<typeof TuplePyDsl>) => TuplePyDsl; /** Creates a basic type reference or type expression (e.g., Foo or Foo<T>). */
+  type: {
+    /** Creates a type alias declaration (e.g., `type Foo = Bar`). */
+    /** Creates an intersection type (e.g., `A & B`). */
+    /** Creates a qualified type reference (e.g., Foo.Bar). */
+    /** Creates a basic type reference or type expression (e.g., Foo or Foo<T>). */
+    /** Converts a runtime value into a corresponding type expression node. */
+    /** Creates a function type node (e.g., `(a: string) => number`). */
+    /** Creates an indexed-access type (e.g., `Foo<T>[K]`). */
+    /** Creates a literal type node (e.g., 'foo', 42, or true). */
+    /** Creates a mapped type (e.g., `{ [K in keyof T]: U }`). */
+    /** Creates a type literal node (e.g., { foo: string }). */
+    /** Creates a type operator node (e.g., `readonly T`, `keyof T`, `unique T`). */
+    /** Creates a union type (e.g., `A | B | C`). */
+    or: (...args: ConstructorParameters<typeof TypeOrPyDsl>) => TypeOrPyDsl;
+    /** Creates a type parameter (e.g., `<T>`). */
+    /** Creates a type query node (e.g., `typeof Foo`). */
+    /** Builds a TypeScript template literal *type* (e.g., `${Foo}-${Bar}` as a type). */
+    /** Creates a tuple type (e.g., [A, B, C]). */
+    tuple: (...args: ConstructorParameters<typeof TypeTuplePyDsl>) => TypeTuplePyDsl;
+  };
+  /** Creates a `typeof` expression (e.g., `typeof value`). */
+  /** Creates a variable assignment. */
+  var: (name?: any) => VarPyDsl; /** Creates a while statement (e.g., `while x:`). */
+  while: (condition: PyExpression | PyDsl<PyExpression, "python">, ...body: (PyExpression | PyStatement | PyDsl<PyExpression | PyStatement, "python">)[]) => WhilePyDsl; /** Creates a with statement (e.g., `with open(f) as file:`). */
+  with: (...args: ConstructorParameters<typeof WithPyDsl>) => WithPyDsl;
+};
+type DollarPyDsl = {
+  /**
+   * Entry point to the Python DSL.
+   *
+   * `$` creates a general expression node by default, but also exposes
+   * builders for all other constructs.
+   *
+   * Example:
+   * ```ts
+   * const node = $('console').attr('log').call($.literal('Hello'));
+   * ```
+   *
+   * Returns:
+   * - A new `ExprPyDsl` instance when called directly.
+   * - The `pyDsl` object for constructing more specific nodes.
+   */
+  $: typeof $$1;
+};
+//#endregion
+//#region src/plugins/@hey-api/sdk/examples.d.ts
+type UserExamplesConfig = Omit<ExampleOptions, 'payload'> & {
+  /**
+   * Whether this feature is enabled.
+   *
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * The programming language for the generated examples.
+   *
+   * This is used to display the language label in code blocks in
+   * documentation UIs.
+   *
+   * @default 'Python'
+   */
+  language?: LinguistLanguages;
+  /**
+   * Example request payload.
+   */
+  payload?: MaybeFunc<(operation: IR$1.OperationObject, ctx: DollarPyDsl) => CallArgs | CallArgs[number]>;
+  /**
+   * Transform the generated example string.
+   *
+   * @param example The generated example string.
+   * @param operation The operation the example was generated for.
+   * @returns The final example string.
+   */
+  transform?: (example: string, operation: IR$1.OperationObject) => string;
+};
+type ExamplesConfig = Omit<ExampleOptions, 'payload'> & FeatureToggle & {
+  /**
+   * The programming language for the generated examples.
+   *
+   * This is used to display the language label in code blocks in
+   * documentation UIs.
+   */
+  language: LinguistLanguages;
+  /**
+   * Example request payload.
+   */
+  payload?: MaybeFunc<(operation: IR$1.OperationObject, ctx: DollarPyDsl) => CallArgs | CallArgs[number]>;
+  /**
+   * Transform the generated example string.
+   *
+   * @param example The generated example string.
+   * @param operation The operation the example was generated for.
+   * @returns The final example string.
+   */
+  transform?: (example: string, operation: IR$1.OperationObject) => string;
+};
+//#endregion
+//#region src/plugins/@hey-api/sdk/imports.d.ts
+declare function sdkImports(plugin: PluginInstance$1): {
+  Client: any;
+  buildClientParams: any;
+  funcTools: {
+    cachedProperty: any;
+  };
+  typing: {
+    Annotated: any;
+    Any: any;
+    Literal: any;
+    NoReturn: any;
+    Optional: any;
+    Tuple: any;
+    TypeAlias: any;
+    Union: any;
+  };
+};
+type SdkImports = ReturnType<typeof sdkImports>;
+//#endregion
+//#region src/plugins/@hey-api/sdk/operations/types.d.ts
+interface UserOperationsConfig {
+  /**
+   * Type of container for grouped operations.
+   *
+   * Ignored when `strategy` is `'flat'`.
+   *
+   * - `'class'` - Class with methods
+   *
+   * @default 'class'
+   */
+  container?: 'class';
+  /**
+   * Customize container names.
+   *
+   * For `'single'` strategy, this sets the root container name.
+   * For `'byTags'` strategy, this transforms tag names.
+   *
+   * @default 'Sdk' for `'single'` strategy
+   *
+   * @example
+   * // Set root name for single strategy
+   * containerName: 'MyApi'
+   *
+   * @example
+   * // Transform tag names with suffix
+   * containerName: '{{name}}Service'
+   *
+   * @example
+   * // With casing
+   * containerName: { name: '{{name}}Service', casing: 'PascalCase' }
+   */
+  containerName?: NamingRule;
+  /**
+   * Customize method/function names.
+   *
+   * Applied to the final segment of the path (the method name).
+   */
+  methodName?: NamingRule;
+  /**
+   * How methods are attached to class containers.
+   *
+   * Only applies when `container` is `'class'`.
+   *
+   * - `'instance'` - Instance methods, requires `new ClassName(config)`
+   *
+   * @default 'instance'
+   */
+  methods?: 'instance';
+  /**
+   * How to derive nesting structure from operations.
+   *
+   * - `'operationId'` - Split operationId by delimiters (e.g., `users.list` → `Users.list()`)
+   * - `'id'` - Use operation id as-is, no nesting
+   * - Custom function for full control
+   *
+   * @default 'operationId'
+   */
+  nesting?: 'operationId' | 'id' | OperationPathStrategy;
+  /**
+   * Delimiters for splitting operationId.
+   *
+   * Only applies when `nesting` is `'operationId'`.
+   *
+   * @default /[./]/
+   */
+  nestingDelimiters?: RegExp;
+  /**
+   * Customize nesting segment names.
+   *
+   * Applied to intermediate path segments (not the method name).
+   */
+  segmentName?: NamingRule;
+  /**
+   * Grouping strategy.
+   *
+   * - `'byTags'` - One container per operation tag
+   * - `'single'` - All operations in one container
+   * - Custom function for full control
+   *
+   * @default 'single'
+   */
+  strategy?: Exclude<OperationsStrategy, 'flat'>;
+  /**
+   * Default container name for operations without tags.
+   *
+   * Only applies when `strategy` is `'byTags'`.
+   *
+   * @default 'default'
+   */
+  strategyDefaultTag?: string;
+}
+interface OperationsConfig {
+  /**
+   * Type of container for grouped operations.
+   *
+   * Ignored when `strategy` is `'flat'`.
+   *
+   * - `'class'` - Class with methods
+   */
+  container: 'class';
+  /**
+   * Customize container names.
+   *
+   * For `'single'` strategy, this sets the root container name.
+   * For `'byTags'` strategy, this transforms tag names.
+   *
+   * @default 'Sdk' for `'single'` strategy
+   *
+   * @example
+   * // Set root name for single strategy
+   * containerName: 'MyApi'
+   *
+   * @example
+   * // Transform tag names with suffix
+   * containerName: '{{name}}Service'
+   *
+   * @example
+   * // With casing
+   * containerName: { name: '{{name}}Service', case: 'PascalCase' }
+   */
+  containerName: NamingConfig;
+  /**
+   * Customize method/function names.
+   *
+   * Applied to the final segment of the path (the method name).
+   */
+  methodName: NamingConfig;
+  /**
+   * How methods are attached to class containers.
+   *
+   * Only applies when `container` is `'class'`.
+   *
+   * - `'instance'` - Instance methods, requires `new ClassName(config)`
+   */
+  methods: 'instance';
+  /**
+   * How to derive nesting structure from operations.
+   *
+   * - `'operationId'` - Split operationId by delimiters (e.g., `users.list` → `Users.list()`)
+   * - `'id'` - Use operation id as-is, no nesting
+   * - Custom function for full control
+   */
+  nesting: 'operationId' | 'id' | OperationPathStrategy;
+  /**
+   * Delimiters for splitting operationId.
+   *
+   * Only applies when `nesting` is `'operationId'`.
+   */
+  nestingDelimiters: RegExp;
+  /**
+   * Customize nesting segment names.
+   *
+   * Applied to intermediate path segments (not the method name).
+   */
+  segmentName: NamingConfig;
+  /**
+   * Grouping strategy.
+   *
+   * - `'byTags'` - One container per operation tag
+   * - `'single'` - All operations in one container
+   * - Custom function for full control
+   */
+  strategy: Exclude<OperationsStrategy, 'flat'>;
+  /**
+   * Default container name for operations without tags.
+   *
+   * Only applies when `strategy` is `'byTags'`.
+   */
+  strategyDefaultTag: string;
+}
+//#endregion
+//#region src/plugins/@hey-api/sdk/types.d.ts
+type UserConfig$2 = Plugin$1.Name<'@hey-api/python-sdk'> & Plugin$1.Hooks & Plugin$1.UserComments & Plugin$1.UserExports & {
+  /**
+   * Use an internal client instance to send HTTP requests? This is useful if
+   * you don't want to manually pass the client to each SDK function.
+   *
+   * You can customize the selected client output through its plugin. You can
+   * also set `client` to `true` to automatically choose the client from your
+   * defined plugins. If we can't detect a client plugin when using `true`, we
+   * will default to `@hey-api/client-httpx`.
+   *
+   * @default true
+   */
+  client?: PluginClientNames | boolean;
+  /**
+   * Generate code examples for SDK operations and attach them to the
+   * input source (e.g., via `x-codeSamples`).
+   *
+   * Set to `false` to disable example generation entirely, or provide an
+   * object for fine-grained control over the output and post-processing.
+   *
+   * @default false
+   */
+  examples?: boolean | UserExamplesConfig;
+  /**
+   * Define the structure of generated SDK operations.
+   *
+   * String shorthand:
+   * - `'byTags'` – one container per operation tag
+   * - `'single'` – all operations in a single container
+   * - custom function for full control
+   *
+   * Use the object form for advanced configuration.
+   *
+   * @default 'single'
+   */
+  operations?: Exclude<OperationsStrategy, 'flat'> | UserOperationsConfig;
+  /**
+   * Define how request parameters are structured in generated SDK methods.
+   *
+   * - `'flat'` merges parameters into a single object.
+   * - `'grouped'` separates parameters by transport layer.
+   *
+   * Use `'flat'` for simpler calls or `'grouped'` for stricter typing and code clarity.
+   *
+   * @default 'grouped'
+   */
+  paramsStructure?: 'flat' | 'grouped';
+};
+type Config$1 = Plugin$1.Name<'@hey-api/python-sdk'> & Plugin$1.Hooks & Plugin$1.Comments & Plugin$1.Exports & {
+  /**
+   * Use an internal client instance to send HTTP requests? This is useful if
+   * you don't want to manually pass the client to each SDK function.
+   *
+   * You can customize the selected client output through its plugin. You can
+   * also set `client` to `true` to automatically choose the client from your
+   * defined plugins. If we can't detect a client plugin when using `true`, we
+   * will default to `@hey-api/client-httpx`.
+   *
+   * @default true
+   */
+  client: PluginClientNames | false;
+  /**
+   * Configuration for generating SDK code examples.
+   */
+  examples: ExamplesConfig;
+  /**
+   * Define the structure of generated SDK operations.
+   */
+  operations: OperationsConfig;
+  /**
+   * Define how request parameters are structured in generated SDK methods.
+   *
+   * - `'flat'` merges parameters into a single object.
+   * - `'grouped'` separates parameters by transport layer.
+   *
+   * Use `'flat'` for simpler calls or `'grouped'` for stricter typing and code clarity.
+   *
+   * @default 'grouped'
+   */
+  paramsStructure: 'flat' | 'grouped';
+};
+type HeyApiSdkPlugin = DefinePlugin$2<UserConfig$2, Config$1, never, SdkImports>;
+//#endregion
+//#region src/plugins/pydantic/imports.d.ts
+declare function pydanticImports(plugin: PluginInstance$1): {
+  datetime: {
+    date: any;
+    datetime: any;
+    time: any;
+    timedelta: any;
+  };
+  enum: {
+    Enum: any;
+    IntEnum: any;
+    StrEnum: any;
+  };
+  typing: {
+    Annotated: any;
+    Any: any;
+    Literal: any;
+    NoReturn: any;
+    Optional: any;
+    Tuple: any;
+    TypeAlias: any;
+    Union: any;
+  };
+  uuid: {
+    UUID: any;
+  };
+  AnyUrl: any;
+  BaseModel: any;
+  ConfigDict: any;
+  EmailStr: any;
+  Field: any;
+  RootModel: any;
+  dataclass: any;
+};
+type PydanticImports = ReturnType<typeof pydanticImports>;
+//#endregion
+//#region src/plugins/pydantic/dsl/decl/enum.d.ts
+declare const Mixed$4: MixinCtor<abstract new () => PyDsl<PyClassDeclaration, "python">, DocMethods>;
+declare class PydanticEnumDsl extends Mixed$4 {
+  readonly '~dsl' = "PydanticEnumDsl";
+  private _dsl?;
+  private _members;
+  constructor(name: NodeName$1);
+  members(...members: ReadonlyArray<EnumMember>): this;
+  _build(): ReturnType<typeof $$1.enum>;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyClassDeclaration;
+}
+//#endregion
+//#region src/py-dsl/mixins/optional.d.ts
+interface OptionalMethods extends Node$1 {
+  _optional?: boolean;
+  /** Marks the node as optional when the condition is true. */
+  optional(condition?: boolean): this;
+  /** Marks the node as required when the condition is true. */
+  required(condition?: boolean): this;
+}
+//#endregion
+//#region src/plugins/pydantic/dsl/expr/constraints.d.ts
+interface PydanticFieldConstraints {
+  description?: string;
+  /** Greater than or equal constraint for numbers. */
+  ge?: number;
+  /** Greater than constraint for numbers. */
+  gt?: number;
+  /** Less than or equal constraint for numbers. */
+  le?: number;
+  /** Less than constraint for numbers. */
+  lt?: number;
+  /** Maximum length constraint for strings/arrays. */
+  max_length?: number;
+  /** Minimum length constraint for strings/arrays. */
+  min_length?: number;
+  /** Multiple of constraint for numbers. */
+  multiple_of?: number;
+  /** Regex pattern constraint for strings. */
+  pattern?: RString;
+  title?: string;
+}
+declare class PydanticConstraintsDsl {
+  readonly '~dsl' = "PydanticConstraintsDsl";
+  private _values;
+  get hasValidationConstraints(): boolean;
+  get isEmpty(): boolean;
+  get values(): Readonly<PydanticFieldConstraints>;
+  description(text: string): this;
+  ge(n: number): this;
+  gt(n: number): this;
+  le(n: number): this;
+  lt(n: number): this;
+  maxLength(n: number): this;
+  merge(other: PydanticConstraintsDsl): PydanticConstraintsDsl;
+  minLength(n: number): this;
+  multipleOf(n: number): this;
+  pattern(p: string): this;
+  title(text: string): this;
+}
+//#endregion
+//#region src/plugins/pydantic/dsl/expr/constrained-type.d.ts
+declare class PydanticConstrainedTypeDsl {
+  readonly '~dsl' = "PydanticConstrainedTypeDsl";
+  readonly constraints: PydanticConstraintsDsl;
+  readonly type: NodeName$1 | MaybePyDsl<py.Expression>;
+  constructor(type: NodeName$1 | MaybePyDsl<py.Expression>, constraints?: PydanticConstraintsDsl);
+  mergeConstraints(constraints: PydanticConstraintsDsl): this;
+}
+//#endregion
+//#region src/plugins/pydantic/dsl/decl/field.d.ts
+declare const Mixed$3: MixinCtor<abstract new () => PyDsl<PyStatement, "python">, OptionalMethods>;
+declare class PydanticFieldDsl extends Mixed$3 {
+  readonly '~dsl' = "PydanticFieldDsl";
+  protected plugin: PydanticPlugin['Instance'];
+  private _decision?;
+  private _fieldArgs?;
+  private _pythonName;
+  private _wireName;
+  private _alias?;
+  private _default;
+  private _defaultFactory?;
+  private _deprecated?;
+  private _discriminator?;
+  private _dsl?;
+  private _constrainedType?;
+  private _nullable?;
+  private _unionMembers?;
+  constructor(plugin: PydanticPlugin['Instance'], name: string);
+  get hasAlias(): boolean;
+  alias(name: string): this;
+  default(value: unknown): this;
+  defaultFactory(factory: string): this;
+  deprecated(value: boolean): this;
+  discriminator(field: string): this;
+  metadata(constrainedType: PydanticConstrainedTypeDsl): this;
+  nullable(value: boolean): this;
+  type(constrainedType: PydanticConstrainedTypeDsl | Array<PydanticConstrainedTypeDsl>): this;
+  private _buildUnionVarType;
+  private _constraintsToKwargs;
+  _build(): ReturnType<typeof $$1.field>;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyAssignment;
+}
+//#endregion
+//#region src/plugins/pydantic/shared/types.d.ts
+/** Return type for toType converters. */
+interface PydanticType {
+  /** Discriminator property name, present when this type is a discriminated union. */
+  discriminator?: string;
+  /** Pre-resolved node. */
+  node?: PydanticNode;
+  type?: ReturnType<typeof $.constrainedType>;
+  /** Per-member constrained types for union fields. Present only on union results. */
+  unionMembers?: Array<ReturnType<typeof $.constrainedType>>;
+}
+/** Metadata that flows through schema walking. */
+interface PydanticMeta {
+  /** Default value from schema. */
+  default?: unknown;
+  /** Whether this or any child contains a forward reference. */
+  hasForwardReference: boolean;
+  /** Does this schema explicitly allow null? */
+  nullable: boolean;
+  /** Is this schema read-only? */
+  readonly: boolean;
+}
+/** Result from walking a schema node. */
+interface PydanticResult extends PydanticType {
+  meta: PydanticMeta;
+}
+interface PydanticModelConfig {
+  extra?: 'allow' | 'forbid' | 'ignore';
+  populate_by_name?: boolean;
+}
+/** Discriminated union of all finalized schema outputs. */
+type PydanticNode = {
+  kind: 'alias';
+  type: ReturnType<typeof $.constrainedType>;
+} | {
+  kind: 'enum';
+  members: Array<EnumMember>;
+} | {
+  config?: PydanticModelConfig;
+  fields: Array<ReturnType<typeof $.field>>;
+  kind: 'model';
+} | {
+  discriminator?: string;
+  kind: 'rootModel';
+  type: ReturnType<typeof $.constrainedType>;
+};
+//#endregion
+//#region src/plugins/pydantic/dsl/decl/model.d.ts
+declare const Mixed$2: MixinCtor<abstract new () => PyDsl<PyClassDeclaration, "python">, DocMethods>;
+declare class PydanticModelDsl extends Mixed$2 {
+  readonly '~dsl' = "PydanticModelDsl";
+  protected plugin: PydanticPlugin['Instance'];
+  private _bases;
+  private _configKwargs;
+  private _dsl?;
+  private _fields;
+  constructor(plugin: PydanticPlugin['Instance'], name: NodeName$1);
+  config(options: PydanticModelConfig): this;
+  extends(base: NodeName$1): this;
+  fields(...fields: ReadonlyArray<PydanticFieldDsl>): this;
+  _build(): ReturnType<typeof $$1.class>;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyClassDeclaration;
+}
+//#endregion
+//#region src/plugins/pydantic/dsl/decl/root-model.d.ts
+declare const Mixed$1: MixinCtor<abstract new () => PyDsl<PyClassDeclaration, "python">, DocMethods>;
+declare class PydanticRootModelDsl extends Mixed$1 {
+  readonly '~dsl' = "PydanticRootModelDsl";
+  protected plugin: PydanticPlugin['Instance'];
+  private _discriminator?;
+  private _dsl?;
+  private _type?;
+  constructor(plugin: PydanticPlugin['Instance'], name: NodeName$1);
+  type(constrainedType: PydanticConstrainedTypeDsl): this;
+  discriminator(field: string): this;
+  _build(): ReturnType<typeof $$1.class>;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyClassDeclaration;
+}
+//#endregion
+//#region src/plugins/pydantic/dsl/decl/type-alias.d.ts
+declare const Mixed: abstract new () => PyDsl<PyStatement, "python">;
+declare class PydanticTypeAliasDsl extends Mixed {
+  readonly '~dsl' = "PydanticTypeAliasDsl";
+  readonly aliased?: PydanticConstrainedTypeDsl;
+  protected plugin: PydanticPlugin['Instance'];
+  private _dsl?;
+  constructor(plugin: PydanticPlugin['Instance'], name: NodeName$1, aliased?: PydanticConstrainedTypeDsl);
+  _build(): ReturnType<typeof $$1.var>;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyAssignment;
+}
+//#endregion
+//#region src/plugins/pydantic/dsl/index.d.ts
+declare const $: ((plugin: DefinePlugin<any, any, never, {
+  datetime: {
+    date: any;
+    datetime: any;
+    time: any;
+    timedelta: any;
+  };
+  enum: {
+    Enum: any;
+    IntEnum: any;
+    StrEnum: any;
+  };
+  typing: {
+    Annotated: any;
+    Any: any;
+    Literal: any;
+    NoReturn: any;
+    Optional: any;
+    Tuple: any;
+    TypeAlias: any;
+    Union: any;
+  };
+  uuid: {
+    UUID: any;
+  };
+  AnyUrl: any;
+  BaseModel: any;
+  ConfigDict: any;
+  EmailStr: any;
+  Field: any;
+  RootModel: any;
+  dataclass: any;
+}>, name: NodeName) => PydanticModelDsl) & {
+  /** Constrained type: a type with attached validation constraints and metadata. */constrainedType: (type: any, constraints?: PydanticConstraintsDsl | undefined) => PydanticConstrainedTypeDsl; /** Constraints bag: validation constraints and field metadata. */
+  constraints: () => PydanticConstraintsDsl; /** Pydantic enum class. */
+  enum: (name: NodeName) => PydanticEnumDsl; /** Pydantic field. */
+  field: (plugin: DefinePlugin<any, any, never, {
+    datetime: {
+      date: any;
+      datetime: any;
+      time: any;
+      timedelta: any;
+    };
+    enum: {
+      Enum: any;
+      IntEnum: any;
+      StrEnum: any;
+    };
+    typing: {
+      Annotated: any;
+      Any: any;
+      Literal: any;
+      NoReturn: any;
+      Optional: any;
+      Tuple: any;
+      TypeAlias: any;
+      Union: any;
+    };
+    uuid: {
+      UUID: any;
+    };
+    AnyUrl: any;
+    BaseModel: any;
+    ConfigDict: any;
+    EmailStr: any;
+    Field: any;
+    RootModel: any;
+    dataclass: any;
+  }>, name: string) => PydanticFieldDsl; /** Pydantic model class. */
+  model: (plugin: DefinePlugin<any, any, never, {
+    datetime: {
+      date: any;
+      datetime: any;
+      time: any;
+      timedelta: any;
+    };
+    enum: {
+      Enum: any;
+      IntEnum: any;
+      StrEnum: any;
+    };
+    typing: {
+      Annotated: any;
+      Any: any;
+      Literal: any;
+      NoReturn: any;
+      Optional: any;
+      Tuple: any;
+      TypeAlias: any;
+      Union: any;
+    };
+    uuid: {
+      UUID: any;
+    };
+    AnyUrl: any;
+    BaseModel: any;
+    ConfigDict: any;
+    EmailStr: any;
+    Field: any;
+    RootModel: any;
+    dataclass: any;
+  }>, name: NodeName) => PydanticModelDsl; /** Pydantic RootModel class. */
+  rootModel: (plugin: DefinePlugin<any, any, never, {
+    datetime: {
+      date: any;
+      datetime: any;
+      time: any;
+      timedelta: any;
+    };
+    enum: {
+      Enum: any;
+      IntEnum: any;
+      StrEnum: any;
+    };
+    typing: {
+      Annotated: any;
+      Any: any;
+      Literal: any;
+      NoReturn: any;
+      Optional: any;
+      Tuple: any;
+      TypeAlias: any;
+      Union: any;
+    };
+    uuid: {
+      UUID: any;
+    };
+    AnyUrl: any;
+    BaseModel: any;
+    ConfigDict: any;
+    EmailStr: any;
+    Field: any;
+    RootModel: any;
+    dataclass: any;
+  }>, name: NodeName) => PydanticRootModelDsl; /** Pydantic type alias. */
+  typeAlias: (plugin: DefinePlugin<any, any, never, {
+    datetime: {
+      date: any;
+      datetime: any;
+      time: any;
+      timedelta: any;
+    };
+    enum: {
+      Enum: any;
+      IntEnum: any;
+      StrEnum: any;
+    };
+    typing: {
+      Annotated: any;
+      Any: any;
+      Literal: any;
+      NoReturn: any;
+      Optional: any;
+      Tuple: any;
+      TypeAlias: any;
+      Union: any;
+    };
+    uuid: {
+      UUID: any;
+    };
+    AnyUrl: any;
+    BaseModel: any;
+    ConfigDict: any;
+    EmailStr: any;
+    Field: any;
+    RootModel: any;
+    dataclass: any;
+  }>, name: NodeName, aliased?: PydanticConstrainedTypeDsl | undefined) => PydanticTypeAliasDsl;
+};
+//#endregion
+//#region src/plugins/pydantic/resolvers.d.ts
+type PydanticResolvers = Plugin$1.Resolvers<{
+  /**
+   * Resolver for array schemas.
+   *
+   * Allows customization of how array types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  array?: (ctx: ArrayResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for boolean schemas.
+   *
+   * Allows customization of how boolean types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  boolean?: (ctx: BooleanResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for enum schemas.
+   *
+   * Allows customization of how enum types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  enum?: (ctx: EnumResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for intersection schemas.
+   *
+   * Allows customization of how intersection types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  intersection?: (ctx: IntersectionResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for never schemas.
+   *
+   * Allows customization of how never types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  never?: (ctx: NeverResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for null schemas.
+   *
+   * Allows customization of how null types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  null?: (ctx: NullResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for number schemas.
+   *
+   * Allows customization of how number types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  number?: (ctx: NumberResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for object schemas.
+   *
+   * Allows customization of how object types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  object?: (ctx: ObjectResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for string schemas.
+   *
+   * Allows customization of how string types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  string?: (ctx: StringResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for tuple schemas.
+   *
+   * Allows customization of how tuple types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  tuple?: (ctx: TupleResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for undefined schemas.
+   *
+   * Allows customization of how undefined types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  undefined?: (ctx: UndefinedResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for union schemas.
+   *
+   * Allows customization of how union types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  union?: (ctx: UnionResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for unknown schemas.
+   *
+   * Allows customization of how unknown types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  unknown?: (ctx: UnknownResolverContext) => PydanticType | undefined;
+  /**
+   * Resolver for void schemas.
+   *
+   * Allows customization of how void types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  void?: (ctx: VoidResolverContext) => PydanticType | undefined;
+}>;
+interface BaseContext extends DollarPyDsl, SchemaVisitorContext<PydanticPlugin['Instance']> {}
+interface ArrayResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: ArrayResolverContext) => PydanticType;
+}> {
+  applyModifiers: (result: PydanticResult, opts?: {
+    optional?: boolean;
+  }) => PydanticResult;
+  childResults: Array<PydanticResult>;
+  schema: SchemaWithType<'array'>;
+  walk: Walker<PydanticResult, PydanticPlugin['Instance']>;
+}
+interface BooleanResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: BooleanResolverContext) => PydanticType;
+  const: (ctx: BooleanResolverContext) => PydanticType | undefined;
+}> {
+  schema: SchemaWithType<'boolean'>;
+}
+interface EnumResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: EnumResolverContext) => PydanticType;
+  items: (ctx: EnumResolverContext) => {
+    enumMembers: Array<EnumMember>;
+    isNullable: boolean;
+  };
+}> {
+  schema: SchemaWithType<'enum'>;
+}
+interface IntersectionResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: IntersectionResolverContext) => PydanticType;
+}> {
+  applyModifiers: (result: PydanticResult, opts?: {
+    optional?: boolean;
+  }) => PydanticResult;
+  childResults: Array<PydanticResult>;
+  parentSchema: IR$1.SchemaObject;
+  schema: IR$1.SchemaObject;
+}
+interface NeverResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: NeverResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'never'>;
+}
+interface NullResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: NullResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'null'>;
+}
+interface NumberResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: NumberResolverContext) => PydanticType;
+  const: (ctx: NumberResolverContext) => PydanticType | undefined;
+}> {
+  schema: SchemaWithType<'integer' | 'number'>;
+}
+interface ObjectResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  additionalProperties: (ctx: ObjectResolverContext) => PydanticType | null | undefined;
+  base: (ctx: ObjectResolverContext) => PydanticType;
+  fields: (ctx: ObjectResolverContext) => Array<ReturnType<typeof $.field>>;
+}> {
+  _childResults: Array<PydanticResult>;
+  applyModifiers: (result: PydanticResult, opts: {
+    optional?: boolean;
+  }) => PydanticResult;
+  schema: SchemaWithType<'object'>;
+  walk: Walker<PydanticResult, PydanticPlugin['Instance']>;
+}
+interface StringResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: StringResolverContext) => PydanticType;
+  const: (ctx: StringResolverContext) => PydanticType | undefined;
+  format: (ctx: StringResolverContext) => PydanticType | undefined;
+}> {
+  schema: SchemaWithType<'string'>;
+}
+interface TupleResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: TupleResolverContext) => PydanticType;
+  const: (ctx: TupleResolverContext) => PydanticType | undefined;
+}> {
+  applyModifiers: (result: PydanticResult, opts?: {
+    optional?: boolean;
+  }) => PydanticResult;
+  childResults: Array<PydanticResult>;
+  schema: SchemaWithType<'tuple'>;
+  walk: Walker<PydanticResult, PydanticPlugin['Instance']>;
+}
+interface UndefinedResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: UndefinedResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'undefined'>;
+}
+interface UnionResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: UnionResolverContext) => PydanticType;
+}> {
+  applyModifiers: (result: PydanticResult, opts?: {
+    optional?: boolean;
+  }) => PydanticResult;
+  childResults: Array<PydanticResult>;
+  parentSchema: IR$1.SchemaObject;
+  schema: IR$1.SchemaObject;
+  schemas: ReadonlyArray<IR$1.SchemaObject>;
+}
+interface UnknownResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: UnknownResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'unknown'>;
+}
+interface VoidResolverContext extends BaseContext, Plugin$1.ResolverNodes<{
+  base: (ctx: VoidResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'void'>;
+}
+//#endregion
+//#region src/plugins/pydantic/types.d.ts
+type UserConfig$1 = Plugin$1.Name<'pydantic'> & Plugin$1.Hooks & Plugin$1.UserComments & Plugin$1.UserExports & PydanticResolvers & {
+  /**
+   * Casing convention for generated names.
+   *
+   * @default 'PascalCase'
+   */
+  case?: Casing;
+  /**
+   * Configuration for reusable schema definitions.
+   *
+   * Controls generation of shared Pydantic models that can be referenced
+   * across requests and responses.
+   *
+   * Can be:
+   * - `boolean`: Shorthand for `{ enabled: boolean }`
+   * - `string` or `function`: Shorthand for `{ name: string | function }`
+   * - `object`: Full configuration object
+   *
+   * @default true
+   */
+  definitions?: boolean | NameTransformer | {
+    /**
+     * Casing convention for generated names.
+     *
+     * @default 'PascalCase'
+     */
+    case?: Casing;
+    /**
+     * Whether this feature is enabled.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Naming pattern for generated names.
+     *
+     * @default '{{name}}'
+     */
+    name?: NameTransformer;
+  };
+  /**
+   * How to generate enum types.
+   *
+   * - `'enum'`: Generate Python Enum classes (e.g., `class Status(str, Enum): ...`)
+   * - `'literal'`: Generate Literal type hints (e.g., `Literal["pending", "active"]`)
+   *
+   * @default 'enum'
+   */
+  enums?: 'enum' | 'literal';
+  /**
+   * How to render field constraints.
+   *
+   * - `'field'`: `foo: Optional[int] = Field(default=None, ge=0, le=100)`
+   * - `'annotated'`: `foo: Annotated[Optional[int], Field(ge=0, le=100)] = None`
+   *
+   * @default 'field'
+   */
+  fieldStyle?: 'annotated' | 'field';
+  /**
+   * Model type to generate.
+   *
+   * - `'BaseModel'`: Pydantic `BaseModel` subclass.
+   * - `'dataclass'`: Pydantic `@dataclass` decorator.
+   *
+   * @default 'BaseModel'
+   */
+  modelType?: 'BaseModel' | 'dataclass';
+  /**
+   * Configuration for request-specific Pydantic models.
+   *
+   * Controls generation of Pydantic models for request bodies,
+   * query parameters, path parameters, and headers.
+   *
+   * Can be:
+   * - `boolean`: Shorthand for `{ enabled: boolean }`
+   * - `string` or `function`: Shorthand for `{ name: string | function }`
+   * - `object`: Full configuration object
+   *
+   * @default true
+   */
+  requests?: boolean | NameTransformer | {
+    /**
+     * Configuration for request body Pydantic models.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    body?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'PascalCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default '{{name}}Body'
+       */
+      name?: NameTransformer;
+    };
+    /**
+     * Casing convention for generated names.
+     *
+     * @default 'PascalCase'
+     */
+    case?: Casing;
+    /**
+     * Whether this feature is enabled.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Configuration for request headers Pydantic models.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    headers?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'PascalCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default '{{name}}Headers'
+       */
+      name?: NameTransformer;
+    };
+    /**
+     * Naming pattern for generated names.
+     *
+     * @default '{{name}}Request'
+     */
+    name?: NameTransformer;
+    /**
+     * Configuration for request path parameters Pydantic models.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    path?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'PascalCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default '{{name}}Path'
+       */
+      name?: NameTransformer;
+    };
+    /**
+     * Configuration for request query parameters Pydantic models.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    query?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'PascalCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default '{{name}}Query'
+       */
+      name?: NameTransformer;
+    };
+  };
+  /**
+   * Configuration for response-specific Pydantic models.
+   *
+   * Controls generation of Pydantic models for response bodies,
+   * error responses, and status codes.
+   *
+   * Can be:
+   * - `boolean`: Shorthand for `{ enabled: boolean }`
+   * - `string` or `function`: Shorthand for `{ name: string | function }`
+   * - `object`: Full configuration object
+   *
+   * @default true
+   */
+  responses?: boolean | NameTransformer | {
+    /**
+     * Casing convention for generated names.
+     *
+     * @default 'PascalCase'
+     */
+    case?: Casing;
+    /**
+     * Whether this feature is enabled.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Naming pattern for generated names.
+     *
+     * @default '{{name}}Response'
+     */
+    name?: NameTransformer;
+  };
+  /**
+   * Enable strict mode for Pydantic models?
+   *
+   * When enabled, extra fields not defined in the schema will be rejected.
+   *
+   * This adds `model_config = ConfigDict(extra='forbid')`
+   * to generated models.
+   *
+   * Note: {@link strict} has no effect when `modelType` is `'dataclass'`
+   * as `ConfigDict` is not supported for dataclasses.
+   *
+   * @default false
+   */
+  strict?: boolean;
+  /**
+   * Configuration for webhook-specific Pydantic models.
+   *
+   * Controls generation of Pydantic models for webhook payloads.
+   *
+   * Can be:
+   * - `boolean`: Shorthand for `{ enabled: boolean }`
+   * - `string` or `function`: Shorthand for `{ name: string | function }`
+   * - `object`: Full configuration object
+   *
+   * @default true
+   */
+  webhooks?: boolean | NameTransformer | {
+    /**
+     * Casing convention for generated names.
+     *
+     * @default 'PascalCase'
+     */
+    case?: Casing;
+    /**
+     * Whether this feature is enabled.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Naming pattern for generated names.
+     *
+     * @default '{{name}}Webhook'
+     */
+    name?: NameTransformer;
+  };
+};
+type Config = Plugin$1.Name<'pydantic'> & Plugin$1.Hooks & Plugin$1.Comments & Plugin$1.Exports & PydanticResolvers & {
+  /** Casing convention for generated names. */case: Casing; /** Configuration for reusable schema definitions. */
+  definitions: NamingOptions & FeatureToggle; /** How to generate enum types. */
+  enums: 'enum' | 'literal'; /** How to render field constraints. */
+  fieldStyle: 'annotated' | 'field'; /** Model type to generate. */
+  modelType: 'BaseModel' | 'dataclass'; /** Configuration for request-specific Pydantic models. */
+  requests: NamingOptions & FeatureToggle & {
+    /** Configuration for request body Zod schemas. */body: NamingOptions & FeatureToggle; /** Configuration for request headers Zod schemas. */
+    headers: NamingOptions & FeatureToggle; /** Configuration for request path parameters Zod schemas. */
+    path: NamingOptions & FeatureToggle; /** Configuration for request query parameters Zod schemas. */
+    query: NamingOptions & FeatureToggle;
+  }; /** Configuration for response-specific Pydantic models. */
+  responses: NamingOptions & FeatureToggle; /** Enable strict mode for Pydantic models? */
+  strict: boolean; /** Configuration for webhook-specific Pydantic models. */
+  webhooks: NamingOptions & FeatureToggle;
+};
+type PydanticPlugin = DefinePlugin$2<UserConfig$1, Config, never, PydanticImports>;
+//#endregion
 //#region src/symbols/enum.d.ts
 declare function ENUM(factory: SymbolFactory): {
-  Enum: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
-  IntEnum: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
-  StrEnum: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  Enum: any;
+  IntEnum: any;
+  StrEnum: any;
 };
 type EnumSymbols = ReturnType<typeof ENUM>;
 //#endregion
 //#region src/symbols/typing.d.ts
 declare function TYPING(factory: SymbolFactory): {
-  Annotated: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
-  Any: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
-  Literal: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
-  NoReturn: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
-  Optional: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
-  Tuple: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
-  TypeAlias: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
-  Union: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  Annotated: any;
+  Any: any;
+  Literal: any;
+  NoReturn: any;
+  Optional: any;
+  Tuple: any;
+  TypeAlias: any;
+  Union: any;
 };
 type TypingSymbols = ReturnType<typeof TYPING>;
 //#endregion
@@ -108,7 +2978,7 @@ type TypingSymbols = ReturnType<typeof TYPING>;
  *
  * @param userConfig User provided {@link UserConfig} configuration(s).
  */
-declare function createClient(userConfig?: LazyOrAsync<MaybeArray<UserConfig>>, logger?: Logger$1): Promise<ReadonlyArray<Context>>;
+declare function createClient(userConfig?: LazyOrAsync<MaybeArray<UserConfig>>, logger?: any): Promise<ReadonlyArray<Context>>;
 //#endregion
 //#region src/plugins/config.d.ts
 /**
@@ -168,5 +3038,5 @@ declare namespace Plugins {
   }
 }
 //#endregion
-export { type AnyPluginName, type Coercer, type CoercerMap, type ConfigTable, type DefinePlugin, type IR, Logger, type OpenApi, type OpenApiMetaObject, type OpenApiOperationObject, type OpenApiParameterObject, type OpenApiRequestBodyObject, type OpenApiResponseObject, type OpenApiSchemaObject, OperationPath, OperationStrategy, type Plugin, type PluginContext, type PluginInstance, Plugins, type TableDirectives, type UserConfig, applyNaming, coerce, createClient, defaultPaginationKeywords, defaultPlugins, defineConfig, defineConfigTable, definePluginConfig, plugins_d_exports as plugins, toCase, utils };
+export { type AnyPluginName, type Coercer, type CoercerMap, type ConfigTable, type DefinePlugin$1 as DefinePlugin, type IR, Logger, type OpenApi, type OpenApiMetaObject, type OpenApiOperationObject, type OpenApiParameterObject, type OpenApiRequestBodyObject, type OpenApiResponseObject, type OpenApiSchemaObject, OperationPath, OperationStrategy, type Plugin, type PluginContext, type PluginInstance, Plugins, type TableDirectives, type UserConfig, applyNaming, coerce, createClient, defaultPaginationKeywords, defaultPlugins, defineConfig, defineConfigTable, definePluginConfig, plugins_d_exports as plugins, toCase, utils };
 //# sourceMappingURL=index.d.mts.map