@hey-api/openapi-python 0.0.23

package/dist/plugins-BDUY2dP5.d.mts

@@ -0,0 +1,2941 @@
+import { AnalysisContext, BindingKind, File, FromRef, Language, Node as Node$1, NodeName, NodeNameSanitizer, NodeRelationship, NodeScope, ProjectMeta, Ref, Symbol } from "@hey-api/codegen-core";
+import { Casing, DefinePlugin, FeatureToggle, IR, NameTransformer, NamingConfig, NamingOptions, NamingRule, OperationPathStrategy, OperationsStrategy, Plugin, PluginInstance, SchemaVisitorContext, SchemaWithType, Walker } from "@hey-api/shared";
+import { AnyString, MaybeArray, MaybeFunc } from "@hey-api/types";
+import { LinguistLanguages } from "@hey-api/spec-types";
+
+//#region src/plugins/@hey-api/client-httpx/types.d.ts
+type UserConfig$2 = Plugin.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.Name<'@hey-api/client-httpx'> & {
+  baseUrl: string | number | boolean;
+};
+type HeyApiClientHttpxPlugin = DefinePlugin<UserConfig$2, 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/args.d.ts
+type Arg = NodeName | 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 | MaybePyDsl<py.Expression>;
+type CallCtor = (callee: CallCallee, ...args: CallArgs) => CallPyDsl;
+declare const Mixed$36: MixinCtor<MixinCtor<abstract new () => PyDsl<PyCallExpression, "python">, ExprMethods>, ArgsMethods>;
+declare class CallPyDsl extends Mixed$36 {
+  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' = "heyapi.node";
+  /** 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>): 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/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 | MaybePyDsl<py.Expression>;
+type AttrCtor = (left: AttrLeft, right: NodeName) => AttrPyDsl;
+declare const Mixed$35: MixinCtor<abstract new () => PyDsl<PyMemberExpression, "python">, ExprMethods>;
+declare class AttrPyDsl extends Mixed$35 {
+  readonly '~dsl' = "AttrPyDsl";
+  protected left: Ref<AttrLeft>;
+  constructor(left: AttrLeft, right: NodeName);
+  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$34: abstract new () => PyDsl<PyBinaryExpression, "python">;
+declare class BinaryPyDsl extends Mixed$34 {
+  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/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 | 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 | 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 | 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/expr/expr.d.ts
+type ExprId = NodeName | MaybePyDsl<py.Expression>;
+type ExprCtor = (id: ExprId) => ExprPyDsl;
+declare const Mixed$30: MixinCtor<abstract new () => PyDsl<PyExpression, "python">, ExprMethods>;
+declare class ExprPyDsl extends Mixed$30 {
+  readonly '~dsl' = "ExprPyDsl";
+  protected _exprInput: Ref<ExprId>;
+  constructor(id: ExprId);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): PyExpression;
+}
+//#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, 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 | py.Expression | undefined;
+type ParamFn = (p: ParamPyDsl) => void;
+type ParamName = NodeName | ParamFn;
+type ParamType = NodeName | 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 | 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 | SubscriptExpr>>;
+  protected body: ClassBody;
+  constructor(name: NodeName);
+  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 | 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;
+  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);
+  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 | 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 | MaybePyDsl<py.Expression>;
+declare class FieldPyDsl extends Mixed$25 {
+  readonly '~dsl' = "FieldPyDsl";
+  readonly nameSanitizer: typeof safeKeywordName;
+  protected _type?: Ref<FieldType>;
+  constructor(name?: NodeName);
+  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 | 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, 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, 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);
+  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>;
+  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 | 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 | MaybePyDsl<py.Expression>;
+declare class VarPyDsl extends Mixed$9 {
+  readonly '~dsl' = "VarPyDsl";
+  readonly nameSanitizer: typeof safeRuntimeName;
+  protected _type?: Ref<VarType>;
+  constructor(name?: NodeName);
+  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 | 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(): PyExpression;
+  $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 | 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(): PySubscriptExpression;
+  $validate(): asserts this;
+  private $flatten;
+  private $flattenRefs;
+}
+//#endregion
+//#region src/py-dsl/index.d.ts
+declare const $$1: ((id: ExprId) => 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: AttrLeft, right: NodeName) => 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: CallCallee, ...args: (CallCallee | undefined)[]) => CallPyDsl; /** Creates a class declaration or expression. */
+  class: (name: NodeName) => 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) => EnumPyDsl; /** Creates a general expression node. */
+  expr: (id: ExprId) => ExprPyDsl; /** Creates a field declaration in a class body. */
+  field: (name?: NodeName | undefined) => 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): FuncPyDsl;
+    (name: NodeName, 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) => 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, 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): MethodPyDsl;
+    (name: NodeName, 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: ParamName, 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?: ReturnExpr | undefined) => 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: SubscriptExpr, ...slices: SubscriptExpr[]) => 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?: NodeName | undefined) => 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.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.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.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.OperationObject) => string;
+};
+//#endregion
+//#region src/plugins/@hey-api/sdk/imports.d.ts
+declare function sdkImports(plugin: PluginInstance): {
+  Client: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  buildClientParams: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  funcTools: {
+    cachedProperty: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  };
+  typing: {
+    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>>;
+  };
+};
+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$1 = Plugin.Name<'@hey-api/python-sdk'> & Plugin.Hooks & Plugin.UserComments & Plugin.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.Name<'@hey-api/python-sdk'> & Plugin.Hooks & Plugin.Comments & Plugin.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<UserConfig$1, Config$1, never, SdkImports>;
+//#endregion
+//#region src/plugins/pydantic/imports.d.ts
+declare function pydanticImports(plugin: PluginInstance): {
+  datetime: {
+    date: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    datetime: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    time: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    timedelta: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  };
+  enum: {
+    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>>;
+  };
+  typing: {
+    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>>;
+  };
+  uuid: {
+    UUID: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  };
+  AnyUrl: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  BaseModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  ConfigDict: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  EmailStr: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  Field: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  RootModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  dataclass: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+};
+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);
+  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 | MaybePyDsl<py.Expression>;
+  constructor(type: NodeName | 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);
+  config(options: PydanticModelConfig): this;
+  extends(base: NodeName): 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);
+  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, 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: import("@hey-api/shared").PluginInstance<import("@hey-api/shared").Plugin.Types<UserConfig, Config, never, {
+  datetime: {
+    date: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    datetime: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    time: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    timedelta: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  };
+  enum: {
+    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>>;
+  };
+  typing: {
+    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>>;
+  };
+  uuid: {
+    UUID: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  };
+  AnyUrl: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  BaseModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  ConfigDict: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  EmailStr: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  Field: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  RootModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  dataclass: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+}>>, name: import("@hey-api/codegen-core").NodeName) => PydanticModelDsl) & {
+  /** Constrained type: a type with attached validation constraints and metadata. */constrainedType: (type: PyExpression | import("@hey-api/codegen-core").NodeName | PyDsl<PyExpression, "python">, constraints?: PydanticConstraintsDsl | undefined) => PydanticConstrainedTypeDsl; /** Constraints bag: validation constraints and field metadata. */
+  constraints: () => PydanticConstraintsDsl; /** Pydantic enum class. */
+  enum: (name: import("@hey-api/codegen-core").NodeName) => PydanticEnumDsl; /** Pydantic field. */
+  field: (plugin: import("@hey-api/shared").PluginInstance<import("@hey-api/shared").Plugin.Types<UserConfig, Config, never, {
+    datetime: {
+      date: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      datetime: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      time: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      timedelta: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    };
+    enum: {
+      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>>;
+    };
+    typing: {
+      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>>;
+    };
+    uuid: {
+      UUID: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    };
+    AnyUrl: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    BaseModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    ConfigDict: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    EmailStr: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    Field: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    RootModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    dataclass: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  }>>, name: string) => PydanticFieldDsl; /** Pydantic model class. */
+  model: (plugin: import("@hey-api/shared").PluginInstance<import("@hey-api/shared").Plugin.Types<UserConfig, Config, never, {
+    datetime: {
+      date: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      datetime: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      time: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      timedelta: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    };
+    enum: {
+      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>>;
+    };
+    typing: {
+      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>>;
+    };
+    uuid: {
+      UUID: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    };
+    AnyUrl: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    BaseModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    ConfigDict: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    EmailStr: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    Field: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    RootModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    dataclass: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  }>>, name: import("@hey-api/codegen-core").NodeName) => PydanticModelDsl; /** Pydantic RootModel class. */
+  rootModel: (plugin: import("@hey-api/shared").PluginInstance<import("@hey-api/shared").Plugin.Types<UserConfig, Config, never, {
+    datetime: {
+      date: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      datetime: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      time: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      timedelta: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    };
+    enum: {
+      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>>;
+    };
+    typing: {
+      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>>;
+    };
+    uuid: {
+      UUID: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    };
+    AnyUrl: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    BaseModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    ConfigDict: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    EmailStr: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    Field: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    RootModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    dataclass: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  }>>, name: import("@hey-api/codegen-core").NodeName) => PydanticRootModelDsl; /** Pydantic type alias. */
+  typeAlias: (plugin: import("@hey-api/shared").PluginInstance<import("@hey-api/shared").Plugin.Types<UserConfig, Config, never, {
+    datetime: {
+      date: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      datetime: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      time: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+      timedelta: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    };
+    enum: {
+      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>>;
+    };
+    typing: {
+      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>>;
+    };
+    uuid: {
+      UUID: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    };
+    AnyUrl: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    BaseModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    ConfigDict: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    EmailStr: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    Field: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    RootModel: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+    dataclass: import("@hey-api/codegen-core").Symbol<import("@hey-api/codegen-core").Node<unknown, import("@hey-api/codegen-core").Language>>;
+  }>>, name: import("@hey-api/codegen-core").NodeName, aliased?: PydanticConstrainedTypeDsl | undefined) => PydanticTypeAliasDsl;
+};
+//#endregion
+//#region src/plugins/pydantic/resolvers.d.ts
+type PydanticResolvers = Plugin.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.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.ResolverNodes<{
+  base: (ctx: BooleanResolverContext) => PydanticType;
+  const: (ctx: BooleanResolverContext) => PydanticType | undefined;
+}> {
+  schema: SchemaWithType<'boolean'>;
+}
+interface EnumResolverContext extends BaseContext, Plugin.ResolverNodes<{
+  base: (ctx: EnumResolverContext) => PydanticType;
+  items: (ctx: EnumResolverContext) => {
+    enumMembers: Array<EnumMember>;
+    isNullable: boolean;
+  };
+}> {
+  schema: SchemaWithType<'enum'>;
+}
+interface IntersectionResolverContext extends BaseContext, Plugin.ResolverNodes<{
+  base: (ctx: IntersectionResolverContext) => PydanticType;
+}> {
+  applyModifiers: (result: PydanticResult, opts?: {
+    optional?: boolean;
+  }) => PydanticResult;
+  childResults: Array<PydanticResult>;
+  parentSchema: IR.SchemaObject;
+  schema: IR.SchemaObject;
+}
+interface NeverResolverContext extends BaseContext, Plugin.ResolverNodes<{
+  base: (ctx: NeverResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'never'>;
+}
+interface NullResolverContext extends BaseContext, Plugin.ResolverNodes<{
+  base: (ctx: NullResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'null'>;
+}
+interface NumberResolverContext extends BaseContext, Plugin.ResolverNodes<{
+  base: (ctx: NumberResolverContext) => PydanticType;
+  const: (ctx: NumberResolverContext) => PydanticType | undefined;
+}> {
+  schema: SchemaWithType<'integer' | 'number'>;
+}
+interface ObjectResolverContext extends BaseContext, Plugin.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.ResolverNodes<{
+  base: (ctx: StringResolverContext) => PydanticType;
+  const: (ctx: StringResolverContext) => PydanticType | undefined;
+  format: (ctx: StringResolverContext) => PydanticType | undefined;
+}> {
+  schema: SchemaWithType<'string'>;
+}
+interface TupleResolverContext extends BaseContext, Plugin.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.ResolverNodes<{
+  base: (ctx: UndefinedResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'undefined'>;
+}
+interface UnionResolverContext extends BaseContext, Plugin.ResolverNodes<{
+  base: (ctx: UnionResolverContext) => PydanticType;
+}> {
+  applyModifiers: (result: PydanticResult, opts?: {
+    optional?: boolean;
+  }) => PydanticResult;
+  childResults: Array<PydanticResult>;
+  parentSchema: IR.SchemaObject;
+  schema: IR.SchemaObject;
+  schemas: ReadonlyArray<IR.SchemaObject>;
+}
+interface UnknownResolverContext extends BaseContext, Plugin.ResolverNodes<{
+  base: (ctx: UnknownResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'unknown'>;
+}
+interface VoidResolverContext extends BaseContext, Plugin.ResolverNodes<{
+  base: (ctx: VoidResolverContext) => PydanticType;
+}> {
+  schema: SchemaWithType<'void'>;
+}
+//#endregion
+//#region src/plugins/pydantic/types.d.ts
+type UserConfig = Plugin.Name<'pydantic'> & Plugin.Hooks & Plugin.UserComments & Plugin.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.Name<'pydantic'> & Plugin.Hooks & Plugin.Comments & Plugin.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<UserConfig, Config, never, PydanticImports>;
+declare namespace plugins_d_exports {
+  export { clientHttpx, pydantic, sdk };
+}
+declare const clientHttpx: (config?: Omit<UserConfig$2, "name"> | undefined) => import("@hey-api/shared").Plugin.Name<"@hey-api/client-httpx"> & {
+  baseUrl?: string | number | boolean;
+} & {
+  name: "@hey-api/client-httpx";
+};
+declare const sdk: (config?: Omit<UserConfig$1, "name"> | undefined) => import("@hey-api/shared").Plugin.Name<"@hey-api/python-sdk"> & import("@hey-api/shared").Plugin.Hooks & import("@hey-api/shared").UserCommentsOption & import("@hey-api/shared").UserIndexExportOption & {
+  client?: PluginClientNames | boolean;
+  examples?: boolean | UserExamplesConfig;
+  operations?: Exclude<import("@hey-api/shared").OperationsStrategy, "flat"> | UserOperationsConfig;
+  paramsStructure?: "flat" | "grouped";
+} & {
+  name: "@hey-api/python-sdk";
+};
+declare const pydantic: (config?: Omit<UserConfig, "name"> | undefined) => import("@hey-api/shared").Plugin.Name<"pydantic"> & import("@hey-api/shared").Plugin.Hooks & import("@hey-api/shared").UserCommentsOption & import("@hey-api/shared").UserIndexExportOption & PydanticResolvers & {
+  case?: import("@hey-api/shared").Casing;
+  definitions?: boolean | import("@hey-api/shared").NameTransformer | {
+    case?: import("@hey-api/shared").Casing;
+    enabled?: boolean;
+    name?: import("@hey-api/shared").NameTransformer;
+  };
+  enums?: "enum" | "literal";
+  fieldStyle?: "annotated" | "field";
+  modelType?: "BaseModel" | "dataclass";
+  requests?: boolean | import("@hey-api/shared").NameTransformer | {
+    body?: boolean | import("@hey-api/shared").NameTransformer | {
+      case?: import("@hey-api/shared").Casing;
+      enabled?: boolean;
+      name?: import("@hey-api/shared").NameTransformer;
+    };
+    case?: import("@hey-api/shared").Casing;
+    enabled?: boolean;
+    headers?: boolean | import("@hey-api/shared").NameTransformer | {
+      case?: import("@hey-api/shared").Casing;
+      enabled?: boolean;
+      name?: import("@hey-api/shared").NameTransformer;
+    };
+    name?: import("@hey-api/shared").NameTransformer;
+    path?: boolean | import("@hey-api/shared").NameTransformer | {
+      case?: import("@hey-api/shared").Casing;
+      enabled?: boolean;
+      name?: import("@hey-api/shared").NameTransformer;
+    };
+    query?: boolean | import("@hey-api/shared").NameTransformer | {
+      case?: import("@hey-api/shared").Casing;
+      enabled?: boolean;
+      name?: import("@hey-api/shared").NameTransformer;
+    };
+  };
+  responses?: boolean | import("@hey-api/shared").NameTransformer | {
+    case?: import("@hey-api/shared").Casing;
+    enabled?: boolean;
+    name?: import("@hey-api/shared").NameTransformer;
+  };
+  strict?: boolean;
+  webhooks?: boolean | import("@hey-api/shared").NameTransformer | {
+    case?: import("@hey-api/shared").Casing;
+    enabled?: boolean;
+    name?: import("@hey-api/shared").NameTransformer;
+  };
+} & {
+  name: "pydantic";
+};
+//#endregion
+export { PydanticPlugin as a, HeyApiClientHttpxPlugin as c, sdk as i, plugins_d_exports as n, PydanticResolvers as o, pydantic as r, HeyApiSdkPlugin as s, clientHttpx as t };
+//# sourceMappingURL=plugins-BDUY2dP5.d.mts.map